Import assertion

src/compiler/checker.ts

@@ -6352,7 +6352,7 @@ namespace ts {
 
                 function inlineExportModifiers(statements: Statement[]) {
                     // Pass 3: Move all `export {}`'s to `export` modifiers where possible
-                    const index = findIndex(statements, d => isExportDeclaration(d) && !d.moduleSpecifier && !!d.exportClause && isNamedExports(d.exportClause));
+                    const index = findIndex(statements, d => isExportDeclaration(d) && !d.moduleSpecifier && !d.assertClause && !!d.exportClause && isNamedExports(d.exportClause));
                     if (index >= 0) {
                         const exportDecl = statements[index] as ExportDeclaration & { readonly exportClause: NamedExports };
                         const replacements = mapDefined(exportDecl.exportClause.elements, e => {
@@ -6384,7 +6384,8 @@ namespace ts {
                                     exportDecl.exportClause,
                                     replacements
                                 ),
-                                exportDecl.moduleSpecifier
+                                exportDecl.moduleSpecifier,
+                                exportDecl.assertClause
                             );
                         }
                     }
@@ -7029,7 +7030,8 @@ namespace ts {
                                         propertyName && isIdentifier(propertyName) ? factory.createIdentifier(idText(propertyName)) : undefined,
                                         factory.createIdentifier(localName)
                                     )])),
-                                    factory.createStringLiteral(specifier)
+                                    factory.createStringLiteral(specifier),
+                                    /*importClause*/ undefined
                                 ), ModifierFlags.None);
                                 break;
                             }
@@ -7105,15 +7107,17 @@ namespace ts {
                                 // We use `target.parent || target` below as `target.parent` is unset when the target is a module which has been export assigned
                                 // And then made into a default by the `esModuleInterop` or `allowSyntheticDefaultImports` flag
                                 // In such cases, the `target` refers to the module itself already
-                                factory.createStringLiteral(getSpecifierForModuleSymbol(target.parent || target, context))
+                                factory.createStringLiteral(getSpecifierForModuleSymbol(target.parent || target, context)),
+                                 /*assertClause*/ undefined
                             ), ModifierFlags.None);
                             break;
                         case SyntaxKind.NamespaceImport:
                             addResult(factory.createImportDeclaration(
                                 /*decorators*/ undefined,
                                 /*modifiers*/ undefined,
                                 factory.createImportClause(/*isTypeOnly*/ false, /*importClause*/ undefined, factory.createNamespaceImport(factory.createIdentifier(localName))),
-                                factory.createStringLiteral(getSpecifierForModuleSymbol(target, context))
+                                factory.createStringLiteral(getSpecifierForModuleSymbol(target, context)),
+                                 /*assertClause*/ undefined
                             ), ModifierFlags.None);
                             break;
                         case SyntaxKind.NamespaceExport:
@@ -7138,7 +7142,8 @@ namespace ts {
                                             factory.createIdentifier(localName)
                                         )
                                     ])),
-                                factory.createStringLiteral(getSpecifierForModuleSymbol(target.parent || target, context))
+                                factory.createStringLiteral(getSpecifierForModuleSymbol(target.parent || target, context)),
+                                 /*assertClause*/ undefined
                             ), ModifierFlags.None);
                             break;
                         case SyntaxKind.ExportSpecifier:
@@ -37344,11 +37349,18 @@ namespace ts {
             }
         }
 
+        function checkGrammarImportAssertion(declaration: ImportDeclaration | ExportDeclaration) {
+            if (declaration.assertClause && moduleKind !== ModuleKind.ESNext) {
+                grammarErrorOnNode(declaration.assertClause, Diagnostics.Import_assertions_are_only_supported_when_the_module_flag_is_set_to_esnext);
+            }
+        }
+
         function checkImportDeclaration(node: ImportDeclaration) {
             if (checkGrammarModuleElementContext(node, Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) {
                 // If we hit an import declaration in an illegal context, just bail out to avoid cascading errors.
                 return;
             }
+            checkGrammarImportAssertion(node);
             if (!checkGrammarDecoratorsAndModifiers(node) && hasEffectiveModifiers(node)) {
                 grammarErrorOnFirstToken(node, Diagnostics.An_import_declaration_cannot_have_modifiers);
             }
@@ -37423,6 +37435,7 @@ namespace ts {
                 return;
             }
 
+            checkGrammarImportAssertion(node);
             if (!checkGrammarDecoratorsAndModifiers(node) && hasEffectiveModifiers(node)) {
                 grammarErrorOnFirstToken(node, Diagnostics.An_export_declaration_cannot_have_modifiers);
             }
@@ -41313,6 +41326,21 @@ namespace ts {
             return false;
         }
 
+        function checkGrammarImportCallArguments(node: ImportCall, nodeArguments: NodeArray<Expression>): boolean {
+            if (moduleKind !== ModuleKind.ESNext) {
+                if (nodeArguments.length !== 1) {
+                    return grammarErrorOnNode(node, Diagnostics.Dynamic_import_must_have_one_specifier_as_an_argument);
+                }
+                checkGrammarForDisallowedTrailingComma(nodeArguments);
+            }
+            else {
+                if (nodeArguments.length !== 1 && nodeArguments.length !== 2) {
+                    return grammarErrorOnNode(node, Diagnostics.Dynamic_import_must_have_a_specifier_as_arguments_and_an_optional_assertion);
+                }
+            }
+            return false;
+        }
+
         function checkGrammarImportCallExpression(node: ImportCall): boolean {
             if (moduleKind === ModuleKind.ES2015) {
                 return grammarErrorOnNode(node, Diagnostics.Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_esnext_commonjs_amd_system_or_umd);
@@ -41323,13 +41351,12 @@ namespace ts {
             }
 
             const nodeArguments = node.arguments;
-            if (nodeArguments.length !== 1) {
-                return grammarErrorOnNode(node, Diagnostics.Dynamic_import_must_have_one_specifier_as_an_argument);
+            if (checkGrammarImportCallArguments(node, nodeArguments)) {
+                return true;
             }
-            checkGrammarForDisallowedTrailingComma(nodeArguments);
             // see: parseArgumentOrArrayLiteralElement...we use this function which parse arguments of callExpression to parse specifier for dynamic import.
             // parseArgumentOrArrayLiteralElement allows spread element to be in an argument list which is not allowed as specifier in dynamic import.
-            if (isSpreadElement(nodeArguments[0])) {
+            if (nodeArguments.length && isSpreadElement(nodeArguments[0])) {
                 return grammarErrorOnNode(nodeArguments[0], Diagnostics.Specifier_of_dynamic_import_cannot_be_spread_element);
             }
             return false;

src/compiler/diagnosticMessages.json

@@ -1352,14 +1352,18 @@
         "category": "Message",
         "code": 1430
     },
-    "'for await' loops are only allowed at the top level of a file when that file is a module, but this file has no imports or exports. Consider adding an empty 'export {}' to make this file a module.": {
+    "Dynamic import must have a specifier as arguments and an optional assertion": {
         "category": "Error",
         "code": 1431
     },
-    "Top-level 'for await' loops are only allowed when the 'module' option is set to 'esnext' or 'system', and the 'target' option is set to 'es2017' or higher.": {
+    "'for await' loops are only allowed at the top level of a file when that file is a module, but this file has no imports or exports. Consider adding an empty 'export {}' to make this file a module.": {
         "category": "Error",
         "code": 1432
     },
+    "Top-level 'for await' loops are only allowed when the 'module' option is set to 'esnext' or 'system', and the 'target' option is set to 'es2017' or higher.": {
+        "category": "Error",
+        "code": 1433
+    },
 
     "The types of '{0}' are incompatible between these types.": {
         "category": "Error",
@@ -3240,30 +3244,34 @@
         "category": "Error",
         "code": 2796
     },
-    "A mixin class that extends from a type variable containing an abstract construct signature must also be declared 'abstract'.": {
+    "Import assertions are only supported when the '--module' flag is set to 'esnext'.": {
         "category": "Error",
         "code": 2797
     },
-    "The declaration was marked as deprecated here.": {
+    "A mixin class that extends from a type variable containing an abstract construct signature must also be declared 'abstract'.": {
         "category": "Error",
         "code": 2798
     },
-    "Type produces a tuple type that is too large to represent.": {
+    "The declaration was marked as deprecated here.": {
         "category": "Error",
         "code": 2799
     },
-    "Expression produces a tuple type that is too large to represent.": {
+    "Type produces a tuple type that is too large to represent.": {
         "category": "Error",
         "code": 2800
     },
-    "This condition will always return true since the Promise is always truthy.": {
+    "Expression produces a tuple type that is too large to represent.": {
         "category": "Error",
         "code": 2801
     },
-    "Type '{0}' can only be iterated through when using the '--downlevelIteration' flag or with a '--target' of 'es2015' or higher.": {
+    "This condition will always return true since the Promise is always truthy.": {
         "category": "Error",
         "code": 2802
     },
+    "Type '{0}' can only be iterated through when using the '--downlevelIteration' flag or with a '--target' of 'es2015' or higher.": {
+        "category": "Error",
+        "code": 2803
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",

src/compiler/emitter.ts

@@ -1556,6 +1556,10 @@ namespace ts {
                     return emitExportAssignment(<ExportAssignment>node);
                 case SyntaxKind.ExportDeclaration:
                     return emitExportDeclaration(<ExportDeclaration>node);
+                case SyntaxKind.AssertClause:
+                    return emitAssertClause(<AssertClause>node);
+                case SyntaxKind.AssertEntry:
+                    return emitAssertEntry(<AssertEntry>node);
                 case SyntaxKind.NamedExports:
                     return emitNamedExports(<NamedExports>node);
                 case SyntaxKind.NamespaceExport:
@@ -3212,6 +3216,10 @@ namespace ts {
                 writeSpace();
             }
             emit(node.moduleSpecifier);
+            if (node.assertClause) {
+                writeSpace();
+                emit(node.assertClause);
+            }
             writeTrailingSemicolon();
         }
 
@@ -3278,9 +3286,34 @@ namespace ts {
                 writeSpace();
                 emit(node.moduleSpecifier);
             }
+            if (node.assertClause) {
+                writeSpace();
+                emit(node.assertClause);
+            }
             writeTrailingSemicolon();
         }
 
+        function emitAssertClause(node: AssertClause) {
+            emitTokenWithComment(SyntaxKind.AssertKeyword, node.pos, writeKeyword, node);
+            writeSpace();
+            const elements = node.elements;
+            emitList(node, elements, ListFormat.ImportClauseEntries);
+        }
+
+        function emitAssertEntry(node: AssertEntry) {
+            emit(node.name);
+            writePunctuation(":");
+            writeSpace();
+
+            const value = node.value;
+            /** @see {emitPropertyAssignment} */
+            if ((getEmitFlags(value) & EmitFlags.NoLeadingComments) === 0) {
+                const commentRange = getCommentRange(value);
+                emitTrailingCommentsOfPosition(commentRange.pos);
+            }
+            emit(value);
+        }
+
         function emitNamespaceExportDeclaration(node: NamespaceExportDeclaration) {
             let nextPos = emitTokenWithComment(SyntaxKind.ExportKeyword, node.pos, writeKeyword, node);
             writeSpace();
@@ -6194,7 +6227,8 @@ namespace ts {
                             visitList(node.decorators, isDecorator),
                             visitList(node.modifiers, isModifier),
                             visit(node.importClause, isImportClause),
-                            visitExpression(node.moduleSpecifier));
+                            visitExpression(node.moduleSpecifier),
+                            visit(node.assertClause, isAssertClause));
 
                     case SyntaxKind.ImportClause:
                         Debug.type<ImportClause>(node);
@@ -6238,7 +6272,20 @@ namespace ts {
                             visitList(node.modifiers, isModifier),
                             node.isTypeOnly,
                             visit(node.exportClause, isNamedExportBindings),
-                            visitExpression(node.moduleSpecifier));
+                            visitExpression(node.moduleSpecifier),
+                            visit(node.assertClause, isAssertClause));
+
+                    case SyntaxKind.AssertClause:
+                        Debug.type<AssertClause>(node);
+                        return factory.updateAssertClause(node,
+                            visitList(node.elements, isAssertEntry),
+                            node.multiLine);
+
+                    case SyntaxKind.AssertEntry:
+                        Debug.type<AssertEntry>(node);
+                        return factory.updateAssertEntry(node,
+                            visit(node.name, isAssertionKey),
+                            visit(node.value, isStringLiteral));
 
                     case SyntaxKind.NamedExports:
                         Debug.type<NamedExports>(node);