packages/codemode/test/lexical-test262.test.ts
Rama dev · réplica de lectura del repositorio original.
/*
* Portions adapted from Test262 at revision 250f204f23a9249ff204be2baec29600faae7b75:
* - test/language/statements/let/global-use-before-initialization-in-prior-statement.js
* - test/language/statements/let/block-local-use-before-initialization-in-prior-statement.js
* - test/language/statements/const/global-use-before-initialization-in-prior-statement.js
* - test/language/statements/const/block-local-use-before-initialization-in-prior-statement.js
* - test/language/statements/let/block-local-use-before-initialization-in-declaration-statement.js
* - test/language/statements/const/block-local-use-before-initialization-in-declaration-statement.js
* - test/language/statements/let/block-local-closure-set-before-initialization.js
* - test/language/statements/for-of/head-let-bound-names-fordecl-tdz.js
* - test/language/statements/for-in/head-let-bound-names-fordecl-tdz.js
* - test/language/statements/let/syntax/let-iteration-variable-is-freshly-allocated-for-each-iteration-single-let-binding.js
* - test/language/statements/let/syntax/let-iteration-variable-is-freshly-allocated-for-each-iteration-multi-let-binding.js
* - test/language/statements/for-of/head-let-fresh-binding-per-iteration.js
* - test/language/statements/for-in/head-let-fresh-binding-per-iteration.js
* - test/language/statements/for/scope-head-lex-open.js
* - test/language/statements/for/scope-body-lex-open.js
* - test/language/statements/switch/scope-lex-open-case.js
* - test/language/statements/switch/scope-lex-close-case.js
* - test/language/statements/function/dflt-params-ref-prior.js
* - test/language/statements/function/dflt-params-ref-later.js
* - test/language/statements/function/dflt-params-ref-self.js
*
* Copyright (C) 2011, 2014, 2016 the V8 project authors. 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 "./lib/index.js"
const value = async (code: string) => {
const result = await Effect.runPromise(CodeMode.execute({ code, tools: {} }))
if (!result.ok) throw new Error(`expected success, got ${result.error.kind}: ${result.error.message}`)
return result.value
}
describe("Test262 lexical temporal dead zones", () => {
test("program and block bindings exist before initialization", async () => {
expect(
await value(`
const errors = []
try { programLet; let programLet } catch (error) { errors.push(error.name) }
try { programConst; const programConst = 1 } catch (error) { errors.push(error.name) }
try { { blockLet; let blockLet } } catch (error) { errors.push(error.name) }
try { { blockConst; const blockConst = 1 } } catch (error) { errors.push(error.name) }
return errors
`),
).toEqual(["ReferenceError", "ReferenceError", "ReferenceError", "ReferenceError"])
})
test("self-initialization and closure assignment observe the TDZ", async () => {
expect(
await value(`
const errors = []
try { { let item = item + 1 } } catch (error) { errors.push(error.name) }
try { { const item = item + 1 } } catch (error) { errors.push(error.name) }
try {
{
function assign() { item = 1 }
assign()
let item
}
} catch (error) { errors.push(error.name) }
return errors
`),
).toEqual(["ReferenceError", "ReferenceError", "ReferenceError"])
})
test("for-of and for-in bound names are in the head TDZ", async () => {
expect(
await value(`
const errors = []
try { let item = [1]; for (let item of item) {} } catch (error) { errors.push(error.name) }
try { let item = { value: 1 }; for (let item in item) {} } catch (error) { errors.push(error.name) }
return errors
`),
).toEqual(["ReferenceError", "ReferenceError"])
})
})
describe("Test262 lexical loop environments", () => {
test("classic for creates fresh single and multiple bindings", async () => {
expect(
await value(`
const single = []
for (let index = 0; index < 5; ++index) single.push(() => index)
const left = []
const right = []
for (let first = 0, second = 10; first < 5; ++first, ++second) {
left.push(() => first)
right.push(() => second)
}
return [
single.map((read) => read()),
left.map((read) => read()),
right.map((read) => read()),
]
`),
).toEqual([
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[10, 11, 12, 13, 14],
])
})
test("for-of and for-in create fresh bindings", async () => {
expect(
await value(`
const values = []
for (let item of [1, 2, 3]) values.push(() => item)
const keys = {}
for (let key in { first: 1, second: 2, third: 3 }) keys[key] = () => key
return [values.map((read) => read()), keys.first(), keys.second(), keys.third()]
`),
).toEqual([[1, 2, 3], "first", "second", "third"])
})
test("classic for separates declaration and per-iteration environments", async () => {
expect(
await value(`
let before
let testRead
let bodyRead
let updateRead
let run = true
for (
let item = "outside", ignored = before = () => item;
run && (item = "inside", testRead = () => item);
updateRead = () => item
) bodyRead = () => item, run = false
return [before(), testRead(), bodyRead(), updateRead()]
`),
).toEqual(["outside", "inside", "inside", "inside"])
})
})
describe("Test262 switch and parameter environments", () => {
test("switch creates its lexical environment after the discriminant", async () => {
expect(
await value(`
let item = "outside"
let discriminantRead
let selectorRead
let statementRead
switch ((discriminantRead = () => item, null)) {
case (selectorRead = () => item, null):
statementRead = () => item
let item = "inside"
}
return [discriminantRead(), selectorRead(), statementRead()]
`),
).toEqual(["outside", "inside", "inside"])
})
test("all switch cases share one lexical environment that closes afterward", async () => {
expect(
await value(`
let item = "outside"
let firstRead
let secondRead
switch (null) {
case null:
let item = "inside"
firstRead = () => item
case null:
secondRead = () => item
}
return [firstRead(), secondRead(), item]
`),
).toEqual(["inside", "inside", "outside"])
})
test("parameter defaults see prior bindings but not self or later bindings", async () => {
expect(
await value(`
function prior(first, second = first, third = second) { return [first, second, third] }
function later(first = second, second) { return first }
function self(item = item) { return item }
function failure(run) {
try { return run() } catch (error) { return error.name }
}
return [prior(3), failure(later), failure(self)]
`),
).toEqual([[3, 3, 3], "ReferenceError", "ReferenceError"])
})
})