Add some case

microsoft · rbuckton · Sep 20, 2021 · Sep 22, 2020 · Sep 22, 2020 · Sep 22, 2020
commit 4b51ca9dd846e7bb657e1b11aed00193ee297d7b
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -39882,11 +39882,11 @@ namespace ts {
                 checkGrammarForDisallowedTrailingComma(nodeArguments);
             }
             else {
-                if (nodeArguments.length > 2) {
+                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
+            return false;
         }
 
         function checkGrammarImportCallExpression(node: ImportCall): boolean {
@@ -39904,7 +39904,7 @@ namespace ts {
             }
             // 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;

diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
@@ -3188,21 +3188,23 @@ namespace ts {
             emitExpression(node.moduleSpecifier);
             if (node.assertClause) {
                 writeSpace();
-                emit(node.assertClause)
+                emit(node.assertClause);
             }
             writeTrailingSemicolon();
         }
 
         function emitAssertClause(node: AssertClause) {
+            emitTokenWithComment(SyntaxKind.AssertKeyword, node.pos, writeKeyword, node);
+            writeSpace();
             const elements = node.elements;
-            emitExpressionList(node, elements, ListFormat.ImportClauseEntries);
+            emitNodeList(emitAssertEntry, 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) {
@@ -3275,6 +3277,10 @@ namespace ts {
                 writeSpace();
                 emitExpression(node.moduleSpecifier);
             }
+            if (node.assertClause) {
+                writeSpace();
+                emit(node.assertClause);
+            }
             writeTrailingSemicolon();
         }
 

diff --git a/src/compiler/factory/nodeFactory.ts b/src/compiler/factory/nodeFactory.ts
@@ -3856,17 +3856,19 @@ namespace ts {
         }
 
         // @api
-        function createAssertClause(elements: NodeArray<AssertEntry> | undefined): AssertClause {
+        function createAssertClause(elements: NodeArray<AssertEntry>, multiLine?: boolean): AssertClause {
             const node = createBaseNode<AssertClause>(SyntaxKind.AssertClause);
             node.elements = elements;
+            node.multiLine = multiLine;
             node.transformFlags |= TransformFlags.ContainsESNext;
             return node;
         }
 
         // @api
-        function updateAssertClause(node: AssertClause, elements: NodeArray<AssertEntry> | undefined): AssertClause {
+        function updateAssertClause(node: AssertClause, elements: NodeArray<AssertEntry>, multiLine?: boolean): AssertClause {
             return node.elements !== elements
-                ? update(createAssertClause(elements), node)
+                || node.multiLine !== multiLine
+                ? update(createAssertClause(elements, multiLine), node)
                 : node;
         }
 
@@ -3880,7 +3882,7 @@ namespace ts {
         }
 
         // @api
-        function updateAssertEntry (node: AssertEntry, name: AssertionKey, value: StringLiteral): AssertEntry {
+        function updateAssertEntry(node: AssertEntry, name: AssertionKey, value: StringLiteral): AssertEntry {
             return node.name !== name
                 || node.value !== value
                 ? update(createAssertEntry(name, value), node)

diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
@@ -394,7 +394,8 @@ namespace ts {
                 return visitNodes(cbNode, cbNodes, node.decorators) ||
                     visitNodes(cbNode, cbNodes, node.modifiers) ||
                     visitNode(cbNode, (<ImportDeclaration>node).importClause) ||
-                    visitNode(cbNode, (<ImportDeclaration>node).moduleSpecifier);
+                    visitNode(cbNode, (<ImportDeclaration>node).moduleSpecifier) ||
+                    visitNode(cbNode, (<ImportDeclaration>node).assertClause);
             case SyntaxKind.ImportClause:
                 return visitNode(cbNode, (<ImportClause>node).name) ||
                     visitNode(cbNode, (<ImportClause>node).namedBindings);
@@ -417,7 +418,8 @@ namespace ts {
                 return visitNodes(cbNode, cbNodes, node.decorators) ||
                     visitNodes(cbNode, cbNodes, node.modifiers) ||
                     visitNode(cbNode, (<ExportDeclaration>node).exportClause) ||
-                    visitNode(cbNode, (<ExportDeclaration>node).moduleSpecifier);
+                    visitNode(cbNode, (<ExportDeclaration>node).moduleSpecifier) ||
+                    visitNode(cbNode, (<ExportDeclaration>node).assertClause);
             case SyntaxKind.ImportSpecifier:
             case SyntaxKind.ExportSpecifier:
                 return visitNode(cbNode, (<ImportOrExportSpecifier>node).propertyName) ||
@@ -1698,7 +1700,7 @@ namespace ts {
         function isAssertionKey(): boolean {
             return tokenIsIdentifierOrKeyword(token()) ||
                 token() === SyntaxKind.StringLiteral;
-        } 
+        }
 
         function parsePropertyNameWorker(allowComputedPropertyNames: boolean): PropertyName {
             if (token() === SyntaxKind.StringLiteral || token() === SyntaxKind.NumericLiteral) {
@@ -1865,7 +1867,7 @@ namespace ts {
                 case ParsingContext.ObjectBindingElements:
                     return token() === SyntaxKind.OpenBracketToken || token() === SyntaxKind.DotDotDotToken || isLiteralPropertyName();
                 case ParsingContext.AssertEntries:
-                    return isAssertionKey()
+                    return isAssertionKey();
                 case ParsingContext.HeritageClauseElement:
                     // If we see `{ ... }` then only consume it as an expression if it is followed by `,` or `{`
                     // That way we won't consume the body of a class in its heritage clause.
@@ -6915,30 +6917,42 @@ namespace ts {
                 parseExpected(SyntaxKind.FromKeyword);
             }
             const moduleSpecifier = parseModuleSpecifier();
-            const afterSpecifierPos = scanner.getStartPos();
 
             let assertClause: AssertClause | undefined;
             if (token() === SyntaxKind.AssertKeyword && !scanner.hasPrecedingLineBreak()) {
-                assertClause = parseAssertClause(afterSpecifierPos);
+                assertClause = parseAssertClause();
             }
 
             parseSemicolon();
             const node = factory.createImportDeclaration(decorators, modifiers, importClause, moduleSpecifier, assertClause);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
 
-        function parseAssertEntry () {
+        function parseAssertEntry() {
             const pos = getNodePos();
             const name = tokenIsIdentifierOrKeyword(token()) ? parseIdentifierName() : parseLiteralLikeNode(SyntaxKind.StringLiteral) as StringLiteral;
-            parseExpected(SyntaxKind.ColonToken)
+            parseExpected(SyntaxKind.ColonToken);
             const value = parseLiteralLikeNode(SyntaxKind.StringLiteral) as StringLiteral;
             return finishNode(factory.createAssertEntry(name, value), pos);
         }
 
-        function parseAssertClause(pos: number) {
-            parseExpected(SyntaxKind.AssertKeyword)
-            const elements = parseList(ParsingContext.AssertEntries, parseAssertEntry)
-            return finishNode(factory.createAssertClause(elements), pos);
+        function parseAssertClause() {
+            const pos = getNodePos();
+            parseExpected(SyntaxKind.AssertKeyword);
+            const openBracePosition = scanner.getTokenPos();
+            parseExpected(SyntaxKind.OpenBraceToken);
+            const multiLine = scanner.hasPrecedingLineBreak();
+            const elements = parseDelimitedList(ParsingContext.AssertEntries, parseAssertEntry, /*considerSemicolonAsDelimiter*/ true);
+            if (!parseExpected(SyntaxKind.CloseBraceToken)) {
+                const lastError = lastOrUndefined(parseDiagnostics);
+                if (lastError && lastError.code === Diagnostics._0_expected.code) {
+                    addRelatedInfo(
+                        lastError,
+                        createDetachedDiagnostic(fileName, openBracePosition, 1, Diagnostics.The_parser_expected_to_find_a_to_match_the_token_here)
+                    );
+                }
+            }
+            return finishNode(factory.createAssertClause(elements, multiLine), pos);
         }
 
         function tokenAfterImportDefinitelyProducesImportDeclaration() {
@@ -7111,9 +7125,8 @@ namespace ts {
                     moduleSpecifier = parseModuleSpecifier();
                 }
             }
-            if (token() === SyntaxKind.AssertKeyword && !scanner.hasPrecedingLineBreak()) {
-                const posAfterSpecifier = getNodePos();
-                assertClause = parseAssertClause(posAfterSpecifier);
+            if (moduleSpecifier && token() === SyntaxKind.AssertKeyword && !scanner.hasPrecedingLineBreak()) {
+                assertClause = parseAssertClause();
             }
             parseSemicolon();
             setAwaitContext(savedAwaitContext);

diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts
@@ -80,6 +80,7 @@ namespace ts {
         any: SyntaxKind.AnyKeyword,
         as: SyntaxKind.AsKeyword,
         asserts: SyntaxKind.AssertsKeyword,
+        assert: SyntaxKind.AssertKeyword,
         bigint: SyntaxKind.BigIntKeyword,
         boolean: SyntaxKind.BooleanKeyword,
         break: SyntaxKind.BreakKeyword,

diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -2987,12 +2987,13 @@ namespace ts {
         readonly parent: AssertClause;
         readonly name: AssertionKey;
         readonly value: StringLiteral;
-    } 
+    }
 
-    export interface AssertClause extends Node  {
+    export interface AssertClause extends Node {
         readonly kind: SyntaxKind.AssertClause;
         readonly parent: ImportDeclaration | ExportDeclaration
-        readonly elements?: NodeArray<AssertEntry>
+        readonly elements: NodeArray<AssertEntry>;
+        readonly multiLine?: boolean;
     }
 
     export interface NamespaceImport extends NamedDeclaration {
@@ -7009,8 +7010,8 @@ namespace ts {
         updateImportDeclaration(node: ImportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration;
         createImportClause(isTypeOnly: boolean, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined): ImportClause;
         updateImportClause(node: ImportClause, isTypeOnly: boolean, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined): ImportClause;
-        createAssertClause(elements: NodeArray<AssertEntry> | undefined): AssertClause;
-        updateAssertClause(node: AssertClause, elements: NodeArray<AssertEntry> | undefined): AssertClause;
+        createAssertClause(elements: NodeArray<AssertEntry>, multiLine?: boolean): AssertClause;
+        updateAssertClause(node: AssertClause, elements: NodeArray<AssertEntry>, multiLine?: boolean): AssertClause;
         createAssertEntry(name: AssertionKey, value: StringLiteral): AssertEntry;
         updateAssertEntry (node: AssertEntry, name: AssertionKey, value: StringLiteral): AssertEntry;
         createNamespaceImport(name: Identifier): NamespaceImport;

diff --git a/src/compiler/visitorPublic.ts b/src/compiler/visitorPublic.ts
@@ -946,13 +946,14 @@ namespace ts {
 
             case SyntaxKind.AssertClause:
                 return factory.updateAssertClause(<AssertClause>node,
-                    nodesVisitor((node as AssertClause).elements, visitor, isAssertEntry));
+                    nodesVisitor((node as AssertClause).elements, visitor, isAssertEntry),
+                    (node as AssertClause).multiLine);
 
             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));

diff --git a/src/testRunner/unittests/transform.ts b/src/testRunner/unittests/transform.ts
@@ -256,7 +256,7 @@ namespace ts {
                             const exports = [{ name: "x" }];
                             const exportSpecifiers = exports.map(e => factory.createExportSpecifier(e.name, e.name));
                             const exportClause = factory.createNamedExports(exportSpecifiers);
-                            const newEd = factory.updateExportDeclaration(ed, ed.decorators, ed.modifiers, ed.isTypeOnly, exportClause, ed.moduleSpecifier);
+                            const newEd = factory.updateExportDeclaration(ed, ed.decorators, ed.modifiers, ed.isTypeOnly, exportClause, ed.moduleSpecifier, ed.assertClause);
 
                             return newEd as Node as T;
                         }
@@ -293,7 +293,8 @@ namespace ts {
                             /*name*/ undefined,
                             factory.createNamespaceImport(factory.createIdentifier("i0"))
                         ),
-                        /*moduleSpecifier*/ factory.createStringLiteral("./comp1"));
+                        /*moduleSpecifier*/ factory.createStringLiteral("./comp1"),
+                        /*assertClause*/ undefined);
                     return factory.updateSourceFile(sf, [importStar]);
                 }
             }

diff --git a/tests/baselines/reference/importAssertion1(target=es2020).errors.txt b/tests/baselines/reference/importAssertion1(target=es2020).errors.txt
@@ -0,0 +1,66 @@
+tests/cases/conformance/esnext/importAssertion/1.ts(1,14): error TS2796: Import assertions are not available when targeting lower than esnext.
+tests/cases/conformance/esnext/importAssertion/1.ts(2,28): error TS2796: Import assertions are not available when targeting lower than esnext.
+tests/cases/conformance/esnext/importAssertion/1.ts(3,28): error TS2796: Import assertions are not available when targeting lower than esnext.
+tests/cases/conformance/esnext/importAssertion/2.ts(1,28): error TS2796: Import assertions are not available when targeting lower than esnext.
+tests/cases/conformance/esnext/importAssertion/2.ts(2,38): error TS2796: Import assertions are not available when targeting lower than esnext.
+tests/cases/conformance/esnext/importAssertion/3.ts(2,11): error TS1324: Dynamic import must have one specifier as an argument.
+tests/cases/conformance/esnext/importAssertion/3.ts(3,11): error TS1324: Dynamic import must have one specifier as an argument.
+tests/cases/conformance/esnext/importAssertion/3.ts(4,11): error TS1324: Dynamic import must have one specifier as an argument.
+tests/cases/conformance/esnext/importAssertion/3.ts(6,11): error TS1324: Dynamic import must have one specifier as an argument.
+tests/cases/conformance/esnext/importAssertion/3.ts(7,11): error TS1324: Dynamic import must have one specifier as an argument.
+tests/cases/conformance/esnext/importAssertion/3.ts(8,11): error TS1324: Dynamic import must have one specifier as an argument.
+
+
+==== tests/cases/conformance/esnext/importAssertion/0.ts (0 errors) ====
+    export const a = 1;
+    export const b = 2;
+
+==== tests/cases/conformance/esnext/importAssertion/1.ts (3 errors) ====
+    import './0' assert { type: "json" }
+                 ~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2796: Import assertions are not available when targeting lower than esnext.
+    import { a, b } from './0' assert { "type": "json" }
+                               ~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2796: Import assertions are not available when targeting lower than esnext.
+    import * as foo from './0' assert { type: "json" }
+                               ~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2796: Import assertions are not available when targeting lower than esnext.
+    a;
+    b;
+    foo.a;
+    foo.b;
+
+==== tests/cases/conformance/esnext/importAssertion/2.ts (2 errors) ====
+    import { a, b } from './0' assert {}
+                               ~~~~~~~~~
+!!! error TS2796: Import assertions are not available when targeting lower than esnext.
+    import { a as c, b as d } from './0' assert { a: "a", b: "b", c: "c" }
+                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2796: Import assertions are not available when targeting lower than esnext.
+    a;
+    b;
+    c;
+    d;
+
+==== tests/cases/conformance/esnext/importAssertion/3.ts (6 errors) ====
+    const a = import('./0')
+    const b = import('./0', { type: "json" })
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1324: Dynamic import must have one specifier as an argument.
+    const c = import('./0', { type: "json", ttype: "typo" })
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1324: Dynamic import must have one specifier as an argument.
+    const d = import('./0', { })
+              ~~~~~~~~~~~~~~~~~~
+!!! error TS1324: Dynamic import must have one specifier as an argument.
+    declare function foo(): any;
+    const e = import('./0', foo())
+              ~~~~~~~~~~~~~~~~~~~~
+!!! error TS1324: Dynamic import must have one specifier as an argument.
+    const f = import()
+              ~~~~~~~~
+!!! error TS1324: Dynamic import must have one specifier as an argument.
+    const g = import('./0', {}, {})
+              ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1324: Dynamic import must have one specifier as an argument.
+