Something went wrong. Try again.
opencode v2 mirror
Something went wrong. Try again.
TypeScript
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294/* * Portable portions adapted from Test262 at revision * 250f204f23a9249ff204be2baec29600faae7b75. Exact source paths are cited * beside the corresponding tests below. * * Copyright (C) 2013-2017 the V8 project authors. All rights reserved. * Copyright (C) 2018 Valerie Young. All rights reserved. * Copyright (C) 2020 Alexey Shvayka. All rights reserved. * Copyright (C) 2022 Kevin Gibbons. All rights reserved. * Copyright Ecma International. All rights reserved. * Test262 portions are governed by the BSD license in LICENSE.test262. */import { describe, expect, test } from "bun:test"import { Effect } from "effect"import { CodeMode } from "../src/index.js"
const execute = (code: string) => Effect.runPromise(CodeMode.execute({ code, tools: {} }))
const value = async (code: string) => { const result = await execute(code) if (!result.ok) throw new Error(`expected success, got ${result.error.kind}: ${result.error.message}`) return result.value}
describe("confined generators", () => { test("parameters are bound at the call; only the body waits for next()", async () => { expect( await value(` const log = [] function* g(a = log.push("param")) { log.push("body"); yield a } const it = g() log.push("created") it.next() function* bad({ x } = null) { yield x } async function* asyncBad({ x } = null) { yield x } let failures = [] try { bad() } catch (error) { failures.push(error.constructor.name) } try { asyncBad() } catch (error) { failures.push(error.constructor.name) } return [log, failures] `), ).toEqual([ ["param", "created", "body"], ["TypeError", "TypeError"], ]) })
// test/built-ins/GeneratorPrototype/next/return-yield-expr.js test("is lazy and preserves next(value), nested suspension, return, and exhaustion", async () => { expect( await value(` const events = [] function* generate() { events.push("start") const received = yield 1 + (yield 2) return received } const iterator = generate() const before = events.slice() const first = iterator.next(99) const second = iterator.next(3) const third = iterator.next(7) const fourth = iterator.next(8) return [before, events, first, second, third, fourth] `), ).toEqual([ [], ["start"], { value: 2, done: false }, { value: 4, done: false }, { value: 7, done: true }, { done: true }, ]) })
test("routes throw and return through catch and finally", async () => { expect( await value(` function* generate() { try { try { yield "try" } catch (error) { yield "caught " + error } } finally { yield "finally" } } const iterator = generate() return [iterator.next(), iterator.throw("boom"), iterator.return("done"), iterator.next()] `), ).toEqual([ { value: "try", done: false }, { value: "caught boom", done: false }, { value: "finally", done: false }, { value: "done", done: true }, ]) })
test("throws into a suspended generator and after exhaustion", async () => { expect( await value(` function* generate() { yield 1 } const iterator = generate() iterator.next() let suspended let exhausted try { iterator.throw("first") } catch (error) { suspended = error } try { iterator.throw("second") } catch (error) { exhausted = error } return [suspended, exhausted, iterator.next()] `), ).toEqual(["first", "second", { done: true }]) })
test("rejects synchronous generator reentry", async () => { expect( await value(` let iterator function* generate() { try { iterator.next() } catch (error) { return error.name } } iterator = generate() return iterator.next() `), ).toEqual({ value: "TypeError", done: true }) })
test("delegates yield*, forwards next values, and receives the delegate return value", async () => { expect( await value(` function* inner() { const input = yield 1 return input * 2 } function* outer() { const result = yield* inner() return result + 1 } const iterator = outer() return [iterator.next(), iterator.next(4)] `), ).toEqual([ { value: 1, done: false }, { value: 9, done: true }, ]) })
test("delegates throw and return to custom iterators", async () => { expect( await value(` const calls = [] let step = 0 const delegate = { [Symbol.iterator]: () => delegate, next(...args) { calls.push(["next", args.length, args[0]]) step += 1 return step === 1 ? { value: "one", done: false } : { value: "end", done: true } }, throw(value) { calls.push(["throw", value]) return { value: "recovered", done: false } }, return(value) { calls.push(["return", value]) return { value: value + "!", done: true } }, } function* generate() { return yield* delegate } const iterator = generate() const first = iterator.next() const second = iterator.throw("x") const third = iterator.return("stop") return [first, second, third, calls] `), ).toEqual([ { value: "one", done: false }, { value: "recovered", done: false }, { value: "stop!", done: true }, [ ["next", 1, null], ["throw", "x"], ["return", "stop"], ], ]) })
test("uses the missing-throw delegation path for built-in iterables", async () => { expect( await value(` function* generate() { yield* [1, 2] } const iterator = generate() iterator.next() try { iterator.throw("boom") } catch (error) { return error.name } `), ).toBe("TypeError") })
test("exposes only the appropriate iterator symbol and works in for...of", async () => { expect( await value(` function* generate() { yield 1; yield 2 } const iterator = generate() const symbols = [iterator[Symbol.iterator]() === iterator, iterator[Symbol.asyncIterator]] const values = [] for (const item of iterator) values.push(item) return [symbols, values] `), ).toEqual([ [true, null], [1, 2], ]) })
test("accepts generator methods as iterator acquisition results", async () => { expect( await value(` const sync = { *[Symbol.iterator]() { yield 1; yield 2 }, } const asynchronous = { async *[Symbol.asyncIterator]() { yield 3; yield 4 }, } const values = [] for (const item of sync) values.push(item) for await (const item of asynchronous) values.push(item) return values `), ).toEqual([1, 2, 3, 4]) })
test("closes a generator when for...of exits abruptly", async () => { expect( await value(` const events = [] function* generate() { try { yield 1; yield 2 } finally { events.push("closed") } } for (const item of generate()) break return events `), ).toEqual(["closed"]) })
test("async generator requests are promises and execute in request order", async () => { expect( await value(` const events = [] async function* generate() { events.push("start") const input = yield Promise.resolve(1) events.push("received " + input) return Promise.resolve(3) } const iterator = generate() const first = iterator.next() const second = iterator.next(2) const third = iterator.next(4) const promiseFlags = [first instanceof Promise, second instanceof Promise, third instanceof Promise] return [promiseFlags, await Promise.all([first, second, third]), events] `), ).toEqual([ [true, true, true], [{ value: 1, done: false }, { value: 3, done: true }, { done: true }], ["start", "received 2"], ]) })
test("keeps requests queued while a completed generator adopts return values", async () => { expect( await value(` const events = [] let resolve const pending = new Promise((done) => { resolve = done }) async function* generate() { return 1 } const iterator = generate() const first = iterator.next() const returned = iterator.return(pending) const later = first.then(() => iterator.next()).then(() => events.push("later")) returned.then(() => events.push("returned")) await first await Promise.resolve() const before = events.slice() resolve(9) await Promise.all([returned, later]) return [before, events] `), ).toEqual([[], ["returned", "later"]]) })
test("serializes requests made after async generator exhaustion", async () => { expect( await value(` const events = [] let resolve const pending = new Promise((done) => { resolve = done }) async function* generate() { return 1 } const iterator = generate() await iterator.next() const returned = iterator.return(pending).then(() => events.push("returned")) const later = iterator.next().then(() => events.push("later")) await Promise.resolve() const before = events.slice() resolve(9) await Promise.all([returned, later]) return [before, events] `), ).toEqual([[], ["returned", "later"]]) })
test("async generators adopt yielded, returned, and return-request promises", async () => { expect( await value(` async function* yielded() { yield Promise.resolve(1) } async function* returned() { return Promise.resolve(2) } async function* pending() { yield 0 } const first = yielded() const second = returned() const third = pending() const exhausted = returned() await third.next() await exhausted.next() return await Promise.all([ first.next(), second.next(), third.return(Promise.resolve(3)), exhausted.return(Promise.resolve(4)), ]) `), ).toEqual([ { value: 1, done: false }, { value: 2, done: true }, { value: 3, done: true }, { value: 4, done: true }, ]) })
test("awaits return-request promises before injecting completion", async () => { expect( await value(` const events = [] async function* generate() { try { yield 1 } catch (error) { events.push("caught " + error) yield "recovered" } finally { events.push("finally") } } const iterator = generate() const first = await iterator.next() const returned = await iterator.return(Promise.reject("bad")) const beforeNext = events.slice() const last = await iterator.next() return [first, returned, beforeNext, last, events] `), ).toEqual([ { value: 1, done: false }, { value: "recovered", done: false }, ["caught bad"], { done: true }, ["caught bad", "finally"], ]) })
test("loop consumers call iterator next with no arguments", async () => { expect( await value(` const calls = [] let syncStep = 0 const sync = { [Symbol.iterator]: () => sync, next(...args) { calls.push(["sync", args.length]) syncStep += 1 return { value: syncStep, done: syncStep > 1 } }, } let asyncStep = 0 const asynchronous = { [Symbol.asyncIterator]: () => asynchronous, async next(...args) { calls.push(["async", args.length]) asyncStep += 1 return { value: asyncStep, done: asyncStep > 1 } }, } for (const item of sync) {} for await (const item of asynchronous) {} return calls `), ).toEqual([ ["sync", 0], ["sync", 0], ["async", 0], ["async", 0], ]) })
test("supports async generators in for await...of and keeps them out of for...of", async () => { expect( await value(` async function* generate() { yield 1; yield await Promise.resolve(2) } const values = [] for await (const item of generate()) values.push(item) let name try { for (const item of generate()) {} } catch (error) { name = error.name } return [values, name] `), ).toEqual([[1, 2], "TypeError"]) })
test("a returned generator serializes as {} like JSON.stringify", async () => { expect(await value(`function* generate() { yield 1 } return generate()`)).toEqual({}) })
// test/built-ins/GeneratorPrototype/return/from-state-suspended-start.js // test/built-ins/GeneratorPrototype/throw/from-state-suspended-start.js // test/built-ins/GeneratorPrototype/return/from-state-completed.js // test/built-ins/GeneratorPrototype/throw/from-state-completed.js test("honors sync return and throw in suspended-start and completed states", async () => { expect( await value(` const events = [] function* generate() { events.push("body"); yield 1 }
const returned = generate() const startReturn = returned.return(7) const afterReturn = returned.next()
const thrown = generate() let startThrow try { thrown.throw("start") } catch (error) { startThrow = error } const afterThrow = thrown.next() let completedThrow try { thrown.throw("completed") } catch (error) { completedThrow = error }
return [startReturn, afterReturn, startThrow, afterThrow, completedThrow, events] `), ).toEqual([{ value: 7, done: true }, { done: true }, "start", { done: true }, "completed", []]) })
// test/built-ins/AsyncGeneratorPrototype/return/return-suspendedStart-promise.js // test/built-ins/AsyncGeneratorPrototype/throw/throw-suspendedStart.js // test/built-ins/AsyncGeneratorPrototype/return/return-state-completed.js // test/built-ins/AsyncGeneratorPrototype/throw/throw-state-completed.js test("honors async return and throw in suspended-start and completed states", async () => { expect( await value(` const events = [] async function* generate() { events.push("body"); yield 1 }
const returned = generate() const startReturn = await returned.return(Promise.resolve(7)) const afterReturn = await returned.next()
const thrown = generate() let startThrow try { await thrown.throw("start") } catch (error) { startThrow = error } const afterThrow = await thrown.next() let completedThrow try { await thrown.throw("completed") } catch (error) { completedThrow = error }
return [startReturn, afterReturn, startThrow, afterThrow, completedThrow, events] `), ).toEqual([{ value: 7, done: true }, { done: true }, "start", { done: true }, "completed", []]) })
// test/built-ins/AsyncGeneratorPrototype/return/return-suspendedYield-try-finally.js // test/built-ins/AsyncGeneratorPrototype/return/return-suspendedYield-try-finally-return.js // test/built-ins/AsyncGeneratorPrototype/throw/throw-suspendedYield-try-finally-throw.js test("runs finally yields and lets finally completions override requests", async () => { expect( await value(` async function* yielding() { try { yield 1 } finally { yield 2 } } async function* returning() { try { yield 1 } finally { return "override" } } async function* throwing() { try { yield 1 } finally { throw "override" } }
const first = yielding() await first.next() const finallyYield = await first.return("sent") const preservedReturn = await first.next()
const second = returning() await second.next() const overriddenReturn = await second.return("sent")
const third = throwing() await third.next() let overriddenThrow try { await third.throw("sent") } catch (error) { overriddenThrow = error } return [finallyYield, preservedReturn, overriddenReturn, overriddenThrow] `), ).toEqual([{ value: 2, done: false }, { value: "sent", done: true }, { value: "override", done: true }, "override"]) })
// test/language/statements/async-generator/yield-promise-reject-next-catch.js // test/language/statements/async-generator/yield-promise-reject-next-yield-star-sync-iterator.js test("rejects yielded promises and closes direct and sync-delegating async generators", async () => { expect( await value(` async function* direct() { yield Promise.reject("direct") } async function* delegated() { yield* [Promise.reject("delegated"), "unreachable"] } const results = [] for (const iterator of [direct(), delegated()]) { try { await iterator.next() } catch (error) { results.push(error) } results.push(await iterator.next()) } return results `), ).toEqual(["direct", { done: true }, "delegated", { done: true }]) })
// test/built-ins/AsyncFromSyncIteratorPrototype/next/for-await-iterator-next-rejected-promise-close.js // test/built-ins/AsyncFromSyncIteratorPrototype/next/yield-iterator-next-rejected-promise-close.js // test/built-ins/AsyncFromSyncIteratorPrototype/throw/iterator-result-rejected-promise-close.js test("closes sync iterators when async-from-sync values reject", async () => { expect( await value(` const events = [] function* loopSource() { try { yield Promise.reject("loop") } finally { events.push("loop close") } } let loopError try { for await (const item of loopSource()) {} } catch (error) { loopError = error }
function* yieldSource() { try { yield Promise.reject("yield") } finally { events.push("yield close") } } async function* delegate() { yield* yieldSource() } let yieldError try { await delegate().next() } catch (error) { yieldError = error }
const throwing = { [Symbol.iterator]: () => throwing, next: () => ({ value: 1, done: false }), throw: () => ({ value: Promise.reject("throw"), done: false }), return: () => { events.push("throw close"); return {} }, } async function* throwDelegate() { yield* throwing } const iterator = throwDelegate() await iterator.next() let throwError try { await iterator.throw("sent") } catch (error) { throwError = error } return [loopError, yieldError, throwError, events] `), ).toEqual(["loop", "yield", "throw", ["loop close", "yield close", "throw close"]]) })
test("does not close rejected terminal or delegated return values", async () => { expect( await value(` const events = [] const terminal = { [Symbol.iterator]: () => terminal, next: () => ({ value: Promise.reject("terminal"), done: true }), return: () => { events.push("terminal close"); return {} }, } let terminalError try { for await (const item of terminal) {} } catch (error) { terminalError = error }
let returnCount = 0 const returned = { [Symbol.iterator]: () => returned, next: () => ({ value: 1, done: false }), return: () => { returnCount += 1 return { value: Promise.reject("return"), done: false } }, } async function* delegate() { yield* returned } const iterator = delegate() await iterator.next() let returnError try { await iterator.return("sent") } catch (error) { returnError = error } return [terminalError, returnError, returnCount, events] `), ).toEqual(["terminal", "return", 1, []]) })
test("serializes a mixed async next, throw, return, and next request queue", async () => { expect( await value(` async function* generate() { try { try { yield 1; yield 2 } catch (error) { yield "caught " + error } } finally { yield "finally" } } const iterator = generate() const first = iterator.next() const thrown = iterator.throw("x") const returned = iterator.return("done") const last = iterator.next() return await Promise.all([first, thrown, returned, last]) `), ).toEqual([ { value: 1, done: false }, { value: "caught x", done: false }, { value: "finally", done: false }, { value: "done", done: true }, ]) })
// test/built-ins/AsyncGeneratorPrototype/next/request-queue-order.js // test/built-ins/AsyncGeneratorPrototype/throw/request-queue-order-state-executing.js // test/built-ins/AsyncGeneratorPrototype/return/request-queue-order-state-executing.js test("orders async requests enqueued while generators are executing", async () => { expect( await value(` const events = [] let returned, returnRequest async function* returnWhileExecuting() { returnRequest = returned.return(42).then((result) => events.push(["return", result])) yield 1 } returned = returnWhileExecuting() const firstReturn = returned.next().then((result) => events.push(["first return", result])) await Promise.all([firstReturn, returnRequest])
let thrown, throwRequest async function* throwWhileExecuting() { throwRequest = thrown.throw("boom").catch((error) => events.push(["throw", error])) yield 2 } thrown = throwWhileExecuting() const firstThrow = thrown.next().then((result) => events.push(["first throw", result])) await Promise.all([firstThrow, throwRequest])
async function* queued() { yield "first"; yield "second" } const iterator = queued() const first = iterator.next() const second = iterator.next() const third = iterator.next() await Promise.all([ third.then(() => events.push("third")), second.then(() => events.push("second")), first.then(() => events.push("first")), ]) return events `), ).toEqual([ ["first return", { value: 1, done: false }], ["return", { value: 42, done: true }], ["first throw", { value: 2, done: false }], ["throw", "boom"], "first", "second", "third", ]) })
// test/language/statements/async-generator/yield-star-promise-not-unwrapped.js // test/language/statements/async-generator/yield-star-sync-next.js test("preserves async iterator promise values but unwraps async-from-sync values", async () => { expect( await value(` const asyncValue = Promise.resolve("async") const asynchronous = { [Symbol.asyncIterator]: () => asynchronous, next: () => ({ value: asyncValue, done: false }), } const syncValue = Promise.resolve("sync") const synchronous = { [Symbol.iterator]: () => synchronous, next: () => ({ value: syncValue, done: false }), } async function* delegate(value) { yield* value } const asyncResult = await delegate(asynchronous).next() const syncResult = await delegate(synchronous).next() return [asyncResult.value === asyncValue, await asyncResult.value, syncResult] `), ).toEqual([true, "async", { value: "sync", done: false }]) })
test("captures delegated result done before awaiting async-from-sync values", async () => { expect( await value(` const result = { value: Promise.resolve(1), done: false } result.value.then(() => { result.done = true }) const source = { [Symbol.iterator]: () => source, next: () => result, } async function* delegate() { yield* source } return await delegate().next() `), ).toEqual({ value: 1, done: false }) })
// test/language/statements/async-generator/yield-star-async-next.js // test/language/statements/async-generator/yield-star-sync-return.js // test/language/statements/async-generator/yield-star-async-throw.js test("forwards next, return, and throw through sync and async yield delegates", async () => { expect( await value(` const calls = [] const make = (symbol, label) => { let step = 0 const iterator = { [symbol]: () => iterator, next(...args) { calls.push([label, "next", args.length, args[0]]) step += 1 return { value: step, done: false } }, return(value) { calls.push([label, "return", value]) return { value: value + "!", done: true } }, throw(value) { calls.push([label, "throw", value]) return { value: "caught " + value, done: false } }, } return iterator } async function* delegate(iterator) { return yield* iterator } const sync = delegate(make(Symbol.iterator, "sync")) const asynchronous = delegate(make(Symbol.asyncIterator, "async")) const results = [await sync.next(9), await sync.next(2), await sync.throw("x"), await sync.return("stop")] results.push(await asynchronous.next(9), await asynchronous.next(3), await asynchronous.throw("y")) return [results, calls] `), ).toEqual([ [ { value: 1, done: false }, { value: 2, done: false }, { value: "caught x", done: false }, { value: "stop!", done: true }, { value: 1, done: false }, { value: 2, done: false }, { value: "caught y", done: false }, ], [ ["sync", "next", 1, null], ["sync", "next", 1, 2], ["sync", "throw", "x"], ["sync", "return", "stop"], ["async", "next", 1, null], ["async", "next", 1, 3], ["async", "throw", "y"], ], ]) })
// test/language/statements/async-generator/yield-star-sync-return.js // test/language/statements/async-generator/yield-star-async-throw.js test("continues delegation when return and throw report done false", async () => { expect( await value(` let returns = 0 const synchronous = { [Symbol.iterator]: () => synchronous, next: () => ({ value: "next", done: false }), return(value) { returns += 1 return { value: returns === 1 ? "return pending" : value, done: returns > 1 } }, } let throws = 0 const asynchronous = { [Symbol.asyncIterator]: () => asynchronous, next: () => ({ value: "next", done: false }), throw(value) { throws += 1 return { value: throws === 1 ? "throw pending" : value, done: throws > 1 } }, } async function* delegate(iterator) { return yield* iterator } const returned = delegate(synchronous) const thrown = delegate(asynchronous) return [ await returned.next(), await returned.return("first"), await returned.return("second"), await thrown.next(), await thrown.throw("first"), await thrown.throw("second"), ] `), ).toEqual([ { value: "next", done: false }, { value: "return pending", done: false }, { value: "second", done: true }, { value: "next", done: false }, { value: "throw pending", done: false }, { value: "second", done: true }, ]) })
// test/language/expressions/yield/star-rhs-iter-nrml-next-call-non-obj.js // test/language/expressions/yield/star-rhs-iter-thrw-thrw-call-non-obj.js // test/language/expressions/yield/star-rhs-iter-rtrn-rtrn-call-non-obj.js // test/language/statements/async-generator/yield-star-next-not-callable-number-throw.js test("rejects malformed yield delegate methods and iterator results", async () => { expect( await value(` const run = (iterator, operation) => { function* generate() { try { yield* iterator } catch (error) { return error.name } } const value = generate() const first = value.next() return operation === "next" ? first : value[operation]() } const iterable = (fields) => ({ [Symbol.iterator]: () => fields }) const nextResult = run(iterable({ next: () => 1 }), "next") const throwResult = run(iterable({ next: () => ({ done: false }), throw: () => 1 }), "throw") const returnResult = run(iterable({ next: () => ({ done: false }), return: () => 1 }), "return")
const badAsync = { [Symbol.asyncIterator]: () => ({ next: 1 }), } async function* asynchronous() { try { yield* badAsync } catch (error) { return error.name } } return [nextResult, throwResult, returnResult, await asynchronous().next()] `), ).toEqual([ { value: "TypeError", done: true }, { value: "TypeError", done: true }, { value: "TypeError", done: true }, { value: "TypeError", done: true }, ]) })
// test/language/expressions/yield/captured-free-vars.js // test/language/statements/generators/dflt-params-ref-prior.js // test/language/expressions/generators/dflt-params-ref-prior.js // test/language/expressions/object/method-definition/generator-no-yield.js test("supports declaration, expression, and method forms with closures and parameters", async () => { expect( await value(` const captured = 4 function* declaration(x, y = x, ...rest) { yield captured + y + rest[0] } const expression = function* (x, y = x) { yield captured + y } const object = { *method({ value }, extra = 1) { return captured + value + extra } } return [declaration(2, undefined, 3).next(), expression(5).next(), object.method({ value: 6 }).next()] `), ).toEqual([ { value: 9, done: false }, { value: 9, done: false }, { value: 11, done: true }, ]) })
// test/language/expressions/assignment/dstr/array-elem-iter-nrml-close.js test("steps holes and rest and closes array binding and assignment patterns early", async () => { expect( await value(` const events = [] function* binding() { try { events.push("b1"); yield 1; events.push("b2"); yield 2; events.push("b3"); yield 3; yield 4 } finally { events.push("binding close") } } const [first, , third] = binding() function* assignment() { try { yield 5; yield 6; yield 7 } finally { events.push("assignment close") } } let head, rest ;[head, ...rest] = assignment() return [first, third, head, rest, events] `), ).toEqual([1, 3, 5, [6, 7], ["b1", "b2", "b3", "binding close", "assignment close"]]) })
// test/language/statements/variable/dstr/ary-ptrn-elem-id-init-throws.js // test/language/expressions/assignment/dstr/array-elem-iter-thrw-close-err.js test("closes on destructuring defaults and preserves the binding error over return failure", async () => { expect( await value(` const events = [] const iterator = { [Symbol.iterator]: () => iterator, next: () => ({ value: undefined, done: false }), return: () => { events.push("close"); throw "close error" }, } let caught try { const [value = (() => { throw "binding error" })()] = iterator } catch (error) { caught = error } return [caught, events] `), ).toEqual(["binding error", ["close"]]) })
test("does not close an exhausted iterator when a destructuring default fails", async () => { expect( await value(` const events = [] const iterator = { [Symbol.iterator]: () => iterator, next: () => ({ done: true }), return: () => { events.push("close"); return {} }, } try { const [item = (() => { throw "default" })()] = iterator } catch {} return events `), ).toEqual([]) })
test("consumes generators in array and argument spread without awaiting yielded promises", async () => { expect( await value(` function* values() { yield 1; yield Promise.resolve(2); yield 3 } const array = [...values()] const args = ((...items) => items)(...values()) return [array[0], array[1] instanceof Promise, await array[1], args[2]] `), ).toEqual([1, true, 2, 3]) })
test("constructs Map, Set, and URLSearchParams from generators lazily", async () => { expect( await value(` const events = [] function* pairs() { events.push(1); yield ["a", 1]; events.push(2); yield ["b", 2] } function* values() { yield 1; yield 1; yield 2 } const map = new Map(pairs()) const set = new Set(values()) const params = new URLSearchParams(pairs()) return [map.get("b"), [...set], params.toString(), events] `), ).toEqual([2, [1, 2], "a=1&b=2", [1, 2, 1, 2]]) })
test("keeps built-in collection iteration live during callbacks", async () => { expect( await value(` const map = new Map([[1, 1], [2, 2]]) const mapped = Array.from(map, (entry, index) => { if (index === 0) map.set(3, 3) return entry[0] }) const set = new Set([1, 2]) const grouped = Map.groupBy(set, (item, index) => { if (index === 0) set.add(3) return "items" }) return [mapped, grouped.get("items")] `), ).toEqual([ [1, 2, 3], [1, 2, 3], ]) })
test("keeps built-in collection iteration live in loops and yield delegation", async () => { expect( await value(` const map = new Map([[1, 1], [2, 2]]) const mapValues = [] for (const [key] of map) { mapValues.push(key) if (key === 1) map.set(3, 3) } const set = new Set([1, 2]) const setValues = [] for await (const item of set) { setValues.push(item) if (item === 1) set.add(3) } const params = new URLSearchParams("a=1&b=2") function* delegate() { yield* params } const iterator = delegate() const first = iterator.next() params.append("c", "3") return [mapValues, setValues, first, iterator.next(), iterator.next()] `), ).toEqual([ [1, 2, 3], [1, 2, 3], { value: ["a", "1"], done: false }, { value: ["b", "2"], done: false }, { value: ["c", "3"], done: false }, ]) })
test("preserves async-from-sync turns for built-in loop completion and close", async () => { expect( await value(` const completed = [] Promise.resolve().then(() => completed.push("reaction")) for await (const item of []) {} completed.push("after")
const closed = [] for await (const item of [1]) { Promise.resolve().then(() => closed.push("reaction")) break } closed.push("after") return [completed, closed] `), ).toEqual([ ["reaction", "after"], ["reaction", "after"], ]) })
test("reads iterator return only when closing", async () => { expect( await value(` const events = [] const iterator = { [Symbol.iterator]: () => iterator, next() { iterator.return = () => { events.push("new"); return {} } return { value: 1, done: false } }, return: () => { events.push("old"); return {} }, } const [item] = iterator return [item, events] `), ).toEqual([1, ["new"]]) })
test("accepts iterable URLSearchParams entry pairs", async () => { expect( await value(` function* pair() { yield "a"; yield 1 } function* entries() { yield pair() } return new URLSearchParams(entries()).toString() `), ).toBe("a=1") })
test("coerces URLSearchParams pair elements like JS and closes both generators", async () => { expect( await value(` const events = [] function* pair() { try { events.push("first") yield Promise.resolve(1) events.push("second") yield 2 } finally { events.push("pair close") } } function* entries() { try { yield pair() } finally { events.push("outer close") } } const params = new URLSearchParams(entries()) return [events, params.toString()] `), ).toEqual([["first", "second", "pair close", "outer close"], "%5Bobject+Promise%5D=2"]) })
test("validates URLSearchParams pair lengths after converting the outer sequence", async () => { expect( await value(` const events = [] function* entries() { try { events.push("one") yield ["a"] events.push("two") yield ["b", 2] } finally { events.push("outer close") } } let name try { new URLSearchParams(entries()) } catch (error) { name = error.name } return [events, name] `), ).toEqual([["one", "two", "outer close"], "TypeError"]) })
test("closes entry constructors when a generator yields a malformed entry", async () => { expect( await value(` const events = [] function* mapEntries() { try { yield ["a", 1]; yield null } finally { events.push("map close") } } function* parameterEntries() { try { yield ["a"]; yield ["b", 2] } finally { events.push("params close") } } const names = [] try { new Map(mapEntries()) } catch (error) { names.push(error.name) } try { new URLSearchParams(parameterEntries()) } catch (error) { names.push(error.name) } return [names, events] `), ).toEqual([ ["TypeError", "TypeError"], ["map close", "params close"], ]) })
// test/built-ins/Array/from/iter-map-fn-args.js // test/built-ins/Array/from/iter-map-fn-err.js test("interleaves Array.from mapping and closes when its mapper fails", async () => { expect( await value(` const events = [] function* source() { try { events.push("next 1"); yield 1; events.push("next 2"); yield 2 } finally { events.push("close") } } const mapped = Array.from(source(), (item) => { events.push("map " + item); return item * 2 }) let caught try { Array.from(source(), (item) => { throw "mapper " + item }) } catch (error) { caught = error } return [mapped, caught, events] `), ).toEqual([[2, 4], "mapper 1", ["next 1", "map 1", "next 2", "map 2", "close", "next 1", "close"]]) })
test("reads array-like Array.from values immediately before mapping", async () => { expect( await value(` const source = { 0: 1, 1: 2, length: 2 } return Array.from(source, (item, index) => { if (index === 0) source[1] = 9 return item }) `), ).toEqual([1, 9]) })
test("interleaves Object.groupBy and Map.groupBy callbacks and closes on callback failure", async () => { expect( await value(` const events = [] function* source() { try { events.push("next"); yield 1; events.push("next"); yield 2 } finally { events.push("close") } } const object = Object.groupBy(source(), (item) => { events.push("object " + item); return item % 2 }) const map = Map.groupBy(source(), (item) => { events.push("map " + item); return item % 2 }) let caught try { Object.groupBy(source(), () => { throw "callback" }) } catch (error) { caught = error } return [object, Object.fromEntries(map), caught, events] `), ).toEqual([ { 0: [2], 1: [1] }, { 0: [2], 1: [1] }, "callback", ["next", "object 1", "next", "object 2", "close", "next", "map 1", "next", "map 2", "close", "next", "close"], ]) })
test("consumes Promise combinator generators in order and observes rejections", async () => { expect( await value(` function* items() { yield Promise.resolve(1); yield Promise.reject("bad"); yield 3 } const settled = await Promise.allSettled(items()) let all, any try { await Promise.all(items()) } catch (error) { all = error } try { await Promise.any((function* () { yield Promise.reject("a"); yield Promise.reject("b") })()) } catch (error) { any = error.errors } const race = await Promise.race((function* () { yield 4; yield Promise.resolve(5) })()) return [settled, all, any, race] `), ).toEqual([ [ { status: "fulfilled", value: 1 }, { status: "rejected", reason: "bad" }, { status: "fulfilled", value: 3 }, ], "bad", ["a", "b"], 4, ]) })
test("finishes Promise combinator iterator consumption before returning the promise", async () => { expect( await value(` const events = [] function* items() { events.push("first"); yield 1; events.push("second"); yield 2 } const promise = Promise.all(items()) events.push("after call") await promise return events `), ).toEqual(["first", "second", "after call"]) })
// test/built-ins/Object/fromEntries/iterator-closed-for-null-entry.js test("closes Object.fromEntries on malformed entries and consumes valid generators", async () => { expect( await value(` const events = [] function* valid() { yield ["a", 1]; yield ["b", 2] } function* invalid() { try { yield ["a", 1]; yield null; yield ["c", 3] } finally { events.push("close") } } let name try { Object.fromEntries(invalid()) } catch (error) { name = error.name } return [Object.fromEntries(valid()), name, events] `), ).toEqual([{ a: 1, b: 2 }, "TypeError", ["close"]]) })
test("consumes AggregateError and Math.sumPrecise generators and closes on invalid numbers", async () => { expect( await value(` const events = [] function* errors() { yield "a"; yield "b" } function* numbers() { yield 1e30; yield 0.1; yield -1e30 } function* invalid() { try { yield 1; yield "bad"; yield 2 } finally { events.push("close") } } const aggregate = new AggregateError(errors(), "message") let name try { Math.sumPrecise(invalid()) } catch (error) { name = error.name } return [aggregate.errors, aggregate.message, Math.sumPrecise(numbers()), name, events] `), ).toEqual([["a", "b"], "message", 0.1, "TypeError", ["close"]]) })
test("rejects async generators in every synchronous iterable consumer", async () => { expect( await value(` async function* source() { yield ["a", 1] } const checks = [ () => [...source()], () => ((...items) => items)(...source()), () => { const [item] = source(); return item }, () => Array.from(source()), () => new Map(source()), () => new Set(source()), () => new URLSearchParams(source()), () => Object.fromEntries(source()), () => Object.groupBy(source(), (item) => item), () => Math.sumPrecise(source()), () => new AggregateError(source()), ] const names = [] for (const check of checks) { try { check() } catch (error) { names.push(error.name) } } try { await Promise.all(source()) } catch (error) { names.push(error.name) } return names `), ).toEqual(Array(12).fill("TypeError")) })
// test/built-ins/Array/from/iter-get-iter-err.js // test/built-ins/Array/from/iter-adv-err.js test("does not close when iterator acquisition or next-result validation fails", async () => { expect( await value(` const events = [] const acquisition = { [Symbol.iterator]: () => { events.push("acquire"); throw "acquisition" } } const malformed = { [Symbol.iterator]: () => malformed, next: () => { events.push("next"); return 1 }, return: () => { events.push("close"); return {} }, } for (const source of [acquisition, malformed]) { try { Array.from(source) } catch {} } return events `), ).toEqual(["acquire", "next"]) })
test("reports synchronous iterator failures before queued promise reactions", async () => { expect( await value(` const events = [] Promise.resolve().then(() => events.push("reaction")) const iterator = { [Symbol.iterator]: () => iterator, next: () => { throw "next" }, } try { Array.from(iterator) } catch { events.push("catch") } await Promise.resolve() return events `), ).toEqual(["catch", "reaction"]) })
test("a generator's return() through for...of or destructuring surfaces a failing close, as break does", async () => { expect( await value(` const make = (ret) => ({ [Symbol.iterator]: () => ({ next: () => ({ done: false, value: [1] }), return: ret }) }) const blanks = (ret) => ({ [Symbol.iterator]: () => ({ next: () => ({ done: false }), return: ret }) }) const outcomes = [] for (const [label, ret] of [ ["null", () => null], ["throws", () => { throw new RangeError("close") }], ["ok", () => ({ done: true })], ]) { function* loop() { for (const [a] of make(ret)) yield a } function* pattern() { for ([ {} = yield ] of [blanks(ret)]) {} } for (const g of [loop(), pattern()]) { g.next() try { g.return(7); outcomes.push(label + " quiet") } catch (e) { outcomes.push(label + " " + e.constructor.name) } } } return outcomes `), ).toEqual(["null TypeError", "null TypeError", "throws RangeError", "throws RangeError", "ok quiet", "ok quiet"]) })})