Add more part of assertion

Author: Kingwl

src/compiler/checker.ts

@@ -35931,11 +35931,19 @@ namespace ts {
             }
         }
 
+        function checkGrammarImportAssertion(declaration: ImportDeclaration | ExportDeclaration) {
+            const target = getEmitScriptTarget(compilerOptions);
+            if (target < ScriptTarget.ESNext && declaration.assertClause) {
+                grammarErrorOnNode(declaration.assertClause, Diagnostics.Import_assertions_are_not_available_when_targeting_lower_than_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);
             }
@@ -36007,6 +36015,7 @@ namespace ts {
                 return;
             }
 
+            checkGrammarImportAssertion(node);
             if (!checkGrammarDecoratorsAndModifiers(node) && hasEffectiveModifiers(node)) {
                 grammarErrorOnFirstToken(node, Diagnostics.An_export_declaration_cannot_have_modifiers);
             }

src/compiler/diagnosticMessages.json

@@ -3055,6 +3055,10 @@
         "category": "Error",
         "code": 2795
     },
+    "Import assertions are not available when targeting lower than esnext.": {
+        "category": "Error",
+        "code": 2796
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",

src/compiler/emitter.ts

@@ -1472,6 +1472,10 @@ namespace ts {
                         return emitImportDeclaration(<ImportDeclaration>node);
                     case SyntaxKind.ImportClause:
                         return emitImportClause(<ImportClause>node);
+                    case SyntaxKind.AssertClause:
+                        return emitAssertClause(<AssertClause>node);
+                    case SyntaxKind.AssertEntry:
+                        return emitAssertEntry(<AssertEntry>node);
                     case SyntaxKind.NamespaceImport:
                         return emitNamespaceImport(<NamespaceImport>node);
                     case SyntaxKind.NamespaceExport:
@@ -3182,9 +3186,32 @@ namespace ts {
                 writeSpace();
             }
             emitExpression(node.moduleSpecifier);
+            if (node.assertClause) {
+                writeSpace();
+                emit(node.assertClause)
+            }
             writeTrailingSemicolon();
         }
 
+        function emitAssertClause(node: AssertClause) {
+            const elements = node.elements;
+            emitExpressionList(node, elements, ListFormat.ImportClauseEntries);
+        }
+
+        function emitAssertEntry(node: AssertEntry) {
+            emit(node.name);
+            writePunctuation(":");
+            writeSpace();
+            
+            const value = node.value;
+            /** @see emitPropertyAssignment */
+            if (emitTrailingCommentsOfPosition && (getEmitFlags(value) & EmitFlags.NoLeadingComments) === 0) {
+                const commentRange = getCommentRange(value);
+                emitTrailingCommentsOfPosition(commentRange.pos);
+            }
+            emit(value);
+        }
+
         function emitImportClause(node: ImportClause) {
             if (node.isTypeOnly) {
                 emitTokenWithComment(SyntaxKind.TypeKeyword, node.pos, writeKeyword, node);

src/compiler/factory/nodeTests.ts

@@ -525,6 +525,10 @@ namespace ts {
         return node.kind === SyntaxKind.AssertEntry;
     }
 
+    export function isAssertionKey(node: Node): node is AssertionKey {
+        return isStringLiteral(node) || isIdentifier(node);
+    }
+
     export function isNamespaceImport(node: Node): node is NamespaceImport {
         return node.kind === SyntaxKind.NamespaceImport;
     }

src/compiler/parser.ts

@@ -398,6 +398,11 @@ namespace ts {
             case SyntaxKind.ImportClause:
                 return visitNode(cbNode, (<ImportClause>node).name) ||
                     visitNode(cbNode, (<ImportClause>node).namedBindings);
+            case SyntaxKind.AssertClause:
+                return visitNodes(cbNode, cbNodes, (<AssertClause>node).elements);
+            case SyntaxKind.AssertEntry:
+                return visitNode(cbNode, (<AssertEntry>node).name) ||
+                    visitNode(cbNode, (<AssertEntry>node).value);
             case SyntaxKind.NamespaceExportDeclaration:
                 return visitNode(cbNode, (<NamespaceExportDeclaration>node).name);
 

src/compiler/types.ts

@@ -7984,6 +7984,7 @@ namespace ts {
         ObjectBindingPatternElements = SingleLine | AllowTrailingComma | SpaceBetweenBraces | CommaDelimited | SpaceBetweenSiblings | NoSpaceIfEmpty,
         ArrayBindingPatternElements = SingleLine | AllowTrailingComma | CommaDelimited | SpaceBetweenSiblings | NoSpaceIfEmpty,
         ObjectLiteralExpressionProperties = PreserveLines | CommaDelimited | SpaceBetweenSiblings | SpaceBetweenBraces | Indented | Braces | NoSpaceIfEmpty,
+        ImportClauseEntries = PreserveLines | CommaDelimited | SpaceBetweenSiblings | SpaceBetweenBraces | Indented | Braces | NoSpaceIfEmpty,
         ArrayLiteralExpressionElements = PreserveLines | CommaDelimited | SpaceBetweenSiblings | AllowTrailingComma | Indented | SquareBrackets,
         CommaListElements = CommaDelimited | SpaceBetweenSiblings | SingleLine,
         CallExpressionArguments = CommaDelimited | SpaceBetweenSiblings | SingleLine | Parenthesis,

src/compiler/visitorPublic.ts

@@ -944,6 +944,15 @@ namespace ts {
                     nodeVisitor((<ImportClause>node).name, visitor, isIdentifier),
                     nodeVisitor((<ImportClause>node).namedBindings, visitor, isNamedImportBindings));
 
+            case SyntaxKind.AssertClause:
+                return factory.updateAssertClause(<AssertClause>node,
+                    nodesVisitor((node as AssertClause).elements, visitor, isAssertEntry));
+
+            case SyntaxKind.AssertEntry:
+                return factory.updateAssertEntry(<AssertEntry>node,
+                    nodeVisitor((<AssertEntry>node).name, visitor, isAssertionKey),
+                    nodeVisitor((<AssertEntry>node).value, visitor, isStringLiteral));
+            
             case SyntaxKind.NamespaceImport:
                 return factory.updateNamespaceImport(<NamespaceImport>node,
                     nodeVisitor((<NamespaceImport>node).name, visitor, isIdentifier));