Diffusion Ant (mir/inline-method) Code

ant/tests/test_jit_inline_special_obj.mjs
3fa05edd2fe3mir/inline-method

test_jit_inline_special_obj.mjs
View Options

			function assert(condition, message) {
			if (!condition) throw new Error(message);
			}

			function assertEq(actual, expected, message) {
			if (actual !== expected) {
			throw new Error(`${message}: expected ${expected}, got ${actual}`);
			}
			}

			function runNewTargetHot() {
			function readNewTarget() {
			return new.target;
			}

			let last = null;
			for (let i = 0; i < 600; i++) {
			last = readNewTarget();
			}
			return last;
			}

			class BaseBox {
			static value = 7;
			}

			class DerivedBox extends BaseBox {
			static readSuperValue() {
			return super.value;
			}
			}

			const superReader = DerivedBox.readSuperValue;

			const staticValueSymbol = Symbol("static-value");

			class SymbolBaseBox {
			static [staticValueSymbol] = 11;
			}

			class SymbolDerivedBox extends SymbolBaseBox {
			static readSuperSymbol() {
			return super[staticValueSymbol];
			}
			}

			const superSymbolReader = SymbolDerivedBox.readSuperSymbol;

			class ConstructorBase {
			get value() {
			return this.tag;
			}
			}

			class ConstructorDerived extends ConstructorBase {
			constructor() {
			super();
			this.tag = "ctor-super";
			this.fromCtor = super.value;
			}
			}

			function runSuperHot() {
			let last = 0;
			for (let i = 0; i < 600; i++) {
			last = superReader();
			}
			return last;
			}

			function runSuperSymbolHot() {
			let last = 0;
			for (let i = 0; i < 600; i++) {
			last = superSymbolReader();
			}
			return last;
			}

			const isAnt = typeof process === "object"
			&& process !== null
			&& typeof process.versions === "object"
			&& process.versions !== null
			&& typeof process.versions.ant === "string";

			assertEq(runNewTargetHot(), undefined, "hot inline helper preserves new.target");
			assertEq(superReader(), 7, "extracted static super value lookup");
			assertEq(runSuperHot(), 7, "hot direct call preserves super value lookup");
			assertEq(superSymbolReader(), 11, "extracted static super symbol lookup");
			assertEq(runSuperSymbolHot(), 11, "hot direct call preserves super symbol lookup");
			assertEq(new ConstructorDerived().fromCtor, "ctor-super", "constructor super getter lookup");

			if (isAnt) {
			const antOnly = await import("./test_jit_inline_special_obj_import.mjs");
			await antOnly.verifyImportBinding(assert, assertEq);
			}

			console.log("OK: test_jit_inline_special_obj");

Owner Packages

No Owners