Support dynamic import call

Fix #1728

Author: ariya

docs/syntax-tree-format.md

@@ -287,7 +287,7 @@ interface MetaProperty {
 ```js
 interface CallExpression {
     type: 'CallExpression';
-    callee: Expression;
+    callee: Expression | Import;
     arguments: ArgumentListElement[];
 }
 
@@ -301,6 +301,10 @@ interface NewExpression {
 with
 
 ```js
+interface Import {
+    type: 'Import';
+}
+
 type ArgumentListElement = Expression | SpreadElement;
 
 interface SpreadElement {

src/messages.ts

@@ -1,5 +1,6 @@
 // Error messages should be identical to V8.
 export const Messages = {
+    BadImportCallArity: 'Unexpected token',
     BadGetterArity: 'Getter must not have any formal parameters',
     BadSetterArity: 'Setter must have exactly one formal parameter',
     BadSetterRestParameter: 'Setter function argument must not be a rest parameter',

src/nodes.ts

@@ -189,9 +189,9 @@ export class BreakStatement {
 
 export class CallExpression {
     readonly type: string;
-    readonly callee: Expression;
+    readonly callee: Expression | Import;
     readonly arguments: ArgumentListElement[];
-    constructor(callee, args) {
+    constructor(callee: Expression | Import, args: ArgumentListElement[]) {
         this.type = Syntax.CallExpression;
         this.callee = callee;
         this.arguments = args;
@@ -469,6 +469,13 @@ export class IfStatement {
     }
 }
 
+export class Import {
+    readonly type: string;
+    constructor() {
+        this.type = Syntax.Import;
+    }
+}
+
 export class ImportDeclaration {
     readonly type: string;
     readonly specifiers: ImportDeclarationSpecifier[];

src/parser.ts

@@ -680,6 +680,8 @@ export class Parser {
                         expr = this.finalize(node, new Node.ThisExpression());
                     } else if (this.matchKeyword('class')) {
                         expr = this.parseClassExpression();
+                    } else if (this.matchImportCall()) {
+                        expr = this.parseImportCall();
                     } else {
                         expr = this.throwUnexpectedToken(this.nextToken());
                     }
@@ -1255,6 +1257,25 @@ export class Parser {
         return args;
     }
 
+    matchImportCall(): boolean {
+        let match = this.matchKeyword('import');
+        if (match) {
+            const state = this.scanner.saveState();
+            this.scanner.scanComments();
+            const next = this.scanner.lex();
+            this.scanner.restoreState(state);
+            match = (next.type === Token.Punctuator) && (next.value === '(');
+        }
+
+        return match;
+    }
+
+    parseImportCall(): Node.Import {
+        const node = this.createNode();
+        this.expectKeyword('import');
+        return this.finalize(node, new Node.Import());
+    }
+
     parseLeftHandSideExpressionAllowCall(): Node.Expression {
         const startToken = this.lookahead;
         const maybeAsync = this.matchContextualKeyword('async');
@@ -1287,6 +1308,9 @@ export class Parser {
                 this.context.isBindingElement = false;
                 this.context.isAssignmentTarget = false;
                 const args = asyncArrow ? this.parseAsyncArguments() : this.parseArguments();
+                if (expr.type === Syntax.Import && args.length !== 1) {
+                    this.tolerateError(Messages.BadImportCallArity);
+                }
                 expr = this.finalize(this.startNode(startToken), new Node.CallExpression(expr, args));
                 if (asyncArrow && this.match('=>')) {
                     expr = {
@@ -1789,10 +1813,14 @@ export class Parser {
                     statement = this.parseExportDeclaration();
                     break;
                 case 'import':
-                    if (!this.context.isModule) {
-                        this.tolerateUnexpectedToken(this.lookahead, Messages.IllegalImportDeclaration);
+                    if (this.matchImportCall()) {
+                        statement = this.parseExpressionStatement();
+                    } else {
+                        if (!this.context.isModule) {
+                            this.tolerateUnexpectedToken(this.lookahead, Messages.IllegalImportDeclaration);
+                        }
+                        statement = this.parseImportDeclaration();
                     }
-                    statement = this.parseImportDeclaration();
                     break;
                 case 'const':
                     statement = this.parseLexicalDeclaration({ inFor: false });

src/syntax.ts

@@ -30,6 +30,7 @@ export const Syntax = {
     FunctionExpression: 'FunctionExpression',
     Identifier: 'Identifier',
     IfStatement: 'IfStatement',
+    Import: 'Import',
     ImportDeclaration: 'ImportDeclaration',
     ImportDefaultSpecifier: 'ImportDefaultSpecifier',
     ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',

test/api-tests.js

@@ -60,6 +60,7 @@ describe('esprima.Syntax', function () {
             FunctionExpression: 'FunctionExpression',
             Identifier: 'Identifier',
             IfStatement: 'IfStatement',
+            Import: 'Import',
             ImportDeclaration: 'ImportDeclaration',
             ImportDefaultSpecifier: 'ImportDefaultSpecifier',
             ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',

test/fixtures/es2017/dynamic-import/coexist-import-call-import-declaration.module.js

@@ -0,0 +1,2 @@
+import $ from "a";
+import("b").then(c);