import.defer-syntax.js

// |jit-test| skip-if: getBuildConfiguration("release_or_beta"); --enable-defer-import-eval

load(libdir + "asserts.js");

const ast = Reflect.parse("import.defer('module.js')");

assertEq(ast.type, "Program");

assertEq(ast.body.length, 1);

assertEq(ast.body[0].type, "ExpressionStatement");

assertEq(ast.body[0].expression.type, "CallImport");

assertEq(ast.body[0].expression.phase, "defer");

assertEq(ast.body[0].expression.ident.type, "Identifier");

assertEq(ast.body[0].expression.ident.name, "import");

assertEq(ast.body[0].expression.arguments.length, 1);

assertEq(ast.body[0].expression.arguments[0].type, "Literal");

assertEq(ast.body[0].expression.arguments[0].value, "module.js");

// `import.defer` accepts an optional second (import attributes) argument,

// like plain dynamic `import()`.

const astWithOptions = Reflect.parse("import.defer('module.js', {with: {type: 'json'}})");

assertEq(astWithOptions.body[0].expression.phase, "defer");

const args = astWithOptions.body[0].expression.arguments;

assertEq(args.length, 2);

assertEq(args[1].type, "ObjectExpression");

// Plain dynamic `import()` is an evaluation-phase call: the `phase` property

// distinguishes it from `import.defer(...)`.

const plainImport = Reflect.parse("import('module.js')");

assertEq(plainImport.body[0].expression.type, "CallImport");

assertEq(plainImport.body[0].expression.phase, "evaluation");

Reflect.parse("while (false) {import.defer('<module defer>');};");

Reflect.parse("function fn() { import.defer('module.js'); }");

Reflect.parse("const fn = () => import.defer('module.js');");

Reflect.parse("for (let i = 0; i < 10; i++) { import.defer('module.js'); }");

Reflect.parse("for (const x of [1, 2, 3]) { import.defer('module.js'); }");

Reflect.parse("for (const key in {a: 1}) { import.defer('module.js'); }");

Reflect.parse("if (true) { import.defer('module.js'); }");

Reflect.parse("if (false) {} else { import.defer('module.js'); }");

Reflect.parse("try { import.defer('module.js'); } catch (e) {}");

Reflect.parse("try {} catch (e) { import.defer('module.js'); }");

Reflect.parse("const mod = 'test'; import.defer(`${mod}.js`);");

Reflect.parse("const x = true ? import.defer('a.js') : import.defer('b.js');");

Reflect.parse("async function fn() { await import.defer('module.js'); }");

Reflect.parse("function* gen() { yield import.defer('module.js'); }");

Reflect.parse("const fn = async () => await import.defer('module.js');");

Reflect.parse("switch (x) { case 1: import.defer('module.js'); break; }");

Reflect.parse("{ import.defer('module.js'); }");

Reflect.parse("function fn() { return import.defer('module.js'); }");

Reflect.parse("const mod = import.defer('module.js');");

Reflect.parse("class C { method() { import.defer('module.js'); } }");

Reflect.parse("import.defer('module' + '.js');");

Reflect.parse("import.defer('module.js',);");

assertThrowsInstanceOf(() => Reflect.parse("typeof import.defer"), SyntaxError);

assertThrowsInstanceOf(() => Reflect.parse("new import.defer('module.js')"), SyntaxError);

assertThrowsInstanceOf(() => Reflect.parse("import.defer()"), SyntaxError);

assertThrowsInstanceOf(() => Reflect.parse("import.defer(...['module.js'])"), SyntaxError);

assertThrowsInstanceOf(() => Reflect.parse("import.defer.property"), SyntaxError);

assertThrowsInstanceOf(() => Reflect.parse("import.defer['module.js']"), SyntaxError);

assertThrowsInstanceOf(() => Reflect.parse("function fn() { return import.defer; }"), SyntaxError);

assertThrowsInstanceOf(() => Reflect.parse("void import.defer"), SyntaxError);

assertThrowsInstanceOf(() => Reflect.parse("!import.defer"), SyntaxError);

assertThrowsInstanceOf(() => Reflect.parse("delete import.defer"), SyntaxError);

assertThrowsInstanceOf(() => Reflect.parse("import.defer++"), SyntaxError);

assertThrowsInstanceOf(() => Reflect.parse("import.defer = 'value'"), SyntaxError);

assertThrowsInstanceOf(() => Reflect.parse("import.defer.foo()"), SyntaxError);

assertThrowsInstanceOf(() => Reflect.parse("import.defer`template`"), SyntaxError);