diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index b10f2e7cb17..5f0e1bd5e92 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -671,6 +671,8 @@ namespace ts {
                     return emitCallExpression(<CallExpression>node);
                 case SyntaxKind.NewExpression:
                     return emitNewExpression(<NewExpression>node);
+                case SyntaxKind.ImportCallExpression:
+                    return emitImportCallExpression(<ImportCallExpression>node);
                 case SyntaxKind.TaggedTemplateExpression:
                     return emitTaggedTemplateExpression(<TaggedTemplateExpression>node);
                 case SyntaxKind.TypeAssertionExpression:
@@ -1153,6 +1155,13 @@ namespace ts {
             emitExpressionList(node, node.arguments, ListFormat.NewExpressionArguments);
         }
 
+        function emitImportCallExpression(node: ImportCallExpression) {
+            write("import");
+            write("(");
+            emitExpression(node.specifier);
+            write(")");
+        }
+
         function emitTaggedTemplateExpression(node: TaggedTemplateExpression) {
             emitExpression(node.tag);
             write(" ");
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index 3ff3bc2782f..0bf545f4fe1 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -503,6 +503,18 @@ namespace ts {
             : node;
     }
 
+    export function createImportCall(specifier: Expression): ImportCallExpression {
+        const node = <ImportCallExpression>createSynthesizedNode(SyntaxKind.ImportCallExpression);
+        node.specifier = specifier;
+        return node;
+    }
+
+    export function updateImportCall(node: ImportCallExpression, specifier: Expression): ImportCallExpression {
+        return node.specifier !== specifier
+            ? updateNode(createImportCall(specifier), node)
+            : node;
+    }
+
     export function createTaggedTemplate(tag: Expression, template: TemplateLiteral) {
         const node = <TaggedTemplateExpression>createSynthesizedNode(SyntaxKind.TaggedTemplateExpression);
         node.tag = parenthesizeForAccess(tag);
diff --git a/src/compiler/transformer.ts b/src/compiler/transformer.ts
index bb1732b57ea..618e626f463 100644
--- a/src/compiler/transformer.ts
+++ b/src/compiler/transformer.ts
@@ -15,6 +15,7 @@
 namespace ts {
     function getModuleTransformer(moduleKind: ModuleKind): TransformerFactory<SourceFile> {
         switch (moduleKind) {
+            case ModuleKind.ES2018:
             case ModuleKind.ES2015:
                 return transformES2015Module;
             case ModuleKind.System:
diff --git a/src/compiler/visitor.ts b/src/compiler/visitor.ts
index 0f4a4ed6561..91ae6560c7d 100644
--- a/src/compiler/visitor.ts
+++ b/src/compiler/visitor.ts
@@ -339,6 +339,10 @@ namespace ts {
                     visitNodes((<CallExpression>node).typeArguments, visitor, isTypeNode),
                     visitNodes((<CallExpression>node).arguments, visitor, isExpression));
 
+            case SyntaxKind.ImportCallExpression:
+                return updateImportCall(<ImportCallExpression>node,
+                    visitNode((<ImportCallExpression>node).specifier, visitor, isExpression));
+
             case SyntaxKind.NewExpression:
                 return updateNew(<NewExpression>node,
                     visitNode((<NewExpression>node).expression, visitor, isExpression),