99596d68ab
Treat ordinary and generator function expressions inside class static blocks as boundaries for await binding names, while still rejecting await as an arrow parameter in the static block itself. Parse field initializers without inheriting an enclosing async function's await-expression context, so script field initializers can resolve await as an identifier while computed field names still use the enclosing expression context. Cover static block function expressions, class field initializers, and the AST shape for an await arrow inside a nested function.
114 lines
2.5 KiB
JavaScript
114 lines
2.5 KiB
JavaScript
test("basic functionality", () => {
|
|
var called = false;
|
|
class A {
|
|
static {
|
|
expect(called).toBeFalse();
|
|
expect(this.name).toBe("A");
|
|
called = true;
|
|
}
|
|
}
|
|
|
|
expect(called).toBeTrue();
|
|
new A();
|
|
expect(called).toBeTrue();
|
|
});
|
|
|
|
test("called in order", () => {
|
|
var i = 0;
|
|
class A {
|
|
static {
|
|
expect(i).toBe(0);
|
|
i++;
|
|
}
|
|
|
|
static method() {
|
|
return 2;
|
|
}
|
|
|
|
static {
|
|
expect(i).toBe(1);
|
|
i++;
|
|
}
|
|
}
|
|
|
|
expect(i).toBe(2);
|
|
new A();
|
|
expect(i).toBe(2);
|
|
});
|
|
|
|
test("correct this", () => {
|
|
var thisValue = null;
|
|
class A {
|
|
static {
|
|
thisValue = this;
|
|
}
|
|
}
|
|
|
|
expect(thisValue).toBe(A);
|
|
});
|
|
|
|
describe("class like constructs can be used inside", () => {
|
|
test("can use new.target", () => {
|
|
let value = 1;
|
|
class C {
|
|
static {
|
|
value = new.target;
|
|
}
|
|
}
|
|
expect(value).toBeUndefined();
|
|
});
|
|
|
|
test("can use super property lookup", () => {
|
|
function parent() {}
|
|
parent.val = 3;
|
|
|
|
let hit = false;
|
|
class C extends parent {
|
|
static {
|
|
hit = true;
|
|
expect(super.val).toBe(3);
|
|
}
|
|
}
|
|
expect(hit).toBeTrue();
|
|
});
|
|
});
|
|
|
|
// https://github.com/LadybirdBrowser/ladybird/pull/4226
|
|
test("declaring variables", () => {
|
|
class A {
|
|
static {
|
|
const a = 1;
|
|
let b = 2;
|
|
var c = 3;
|
|
function d() {}
|
|
|
|
expect(a).toBe(1);
|
|
expect(b).toBe(2);
|
|
expect(c).toBe(3);
|
|
expect(typeof d).toBe("function");
|
|
}
|
|
}
|
|
});
|
|
|
|
test("await binding names in nested functions", () => {
|
|
class A {
|
|
static {
|
|
const makeGenerator = function* await(await) {
|
|
yield await;
|
|
};
|
|
|
|
const generator = makeGenerator(42);
|
|
expect(generator.next()).toEqual({ value: 42, done: false });
|
|
expect(generator.next()).toEqual({ value: undefined, done: true });
|
|
|
|
(function await(await) {
|
|
expect(await).toBe(42);
|
|
})(42);
|
|
}
|
|
}
|
|
});
|
|
|
|
test("await binding names in static blocks without a function boundary", () => {
|
|
expect(`class A { static { await => 0; } }`).not.toEval();
|
|
expect(`class A { static { async function await() {} } }`).not.toEval();
|
|
});
|