feat(53656): Add support for the updated import attributes proposal

src/compiler/diagnosticMessages.json

@@ -19,7 +19,7 @@
         "category": "Error",
         "code": 1007
     },
-    "The 'assert' keyword in import attributes is deprecated and it has been replaced by the 'with' keyword.": {
+    "The 'assert' keyword in import attributes is deprecated and has been replaced by the 'with' keyword.": {
         "category": "Error",
         "code": 1008
     },
@@ -3635,10 +3635,6 @@
         "category": "Error",
         "code": 2840
     },
-    "The type of this expression cannot be named without a 'resolution-mode' assertion, which is an unstable feature. Use nightly TypeScript to silence this error. Try updating with 'npm install -D typescript@next'.": {
-        "category": "Error",
-        "code": 2841
-    },
     "'{0}' is an unused renaming of '{1}'. Did you intend to use it as a type annotation?": {
         "category": "Error",
         "code": 2842
@@ -4132,14 +4128,6 @@
         "category": "Error",
         "code": 4124
     },
-    "'resolution-mode' assertions are unstable. Use nightly TypeScript to silence this error. Try updating with 'npm install -D typescript@next'.": {
-        "category": "Error",
-        "code": 4125
-    },
-    "'resolution-mode' attributes are unstable. Use nightly TypeScript to silence this error. Try updating with 'npm install -D typescript@next'.": {
-        "category": "Error",
-        "code": 4126
-    },
 
     "The current host does not support the '{0}' option.": {
         "category": "Error",

src/compiler/emitter.ts

@@ -7,8 +7,6 @@ import {
     ArrayTypeNode,
     ArrowFunction,
     AsExpression,
-    AssertClause,
-    AssertEntry,
     AwaitExpression,
     base64encode,
     BigIntLiteral,
@@ -2055,10 +2053,6 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri
                     return emitNamedExports(node as NamedExports);
                 case SyntaxKind.ExportSpecifier:
                     return emitExportSpecifier(node as ExportSpecifier);
-                case SyntaxKind.AssertClause:
-                    return emitAssertClause(node as AssertClause);
-                case SyntaxKind.AssertEntry:
-                    return emitAssertEntry(node as AssertEntry);
                 case SyntaxKind.ImportAttributes:
                     return emitImportAttributes(node as ImportAttributes);
                 case SyntaxKind.ImportAttribute:
@@ -2952,25 +2946,12 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri
         writeKeyword("import");
         writePunctuation("(");
         emit(node.argument);
-        if (node.assertions) {
-            writePunctuation(",");
-            writeSpace();
-            writePunctuation("{");
-            writeSpace();
-            writeKeyword("assert");
-            writePunctuation(":");
-            writeSpace();
-            const elements = node.assertions.assertClause.elements;
-            emitList(node.assertions.assertClause, elements, ListFormat.ImportClauseEntries);
-            writeSpace();
-            writePunctuation("}");
-        }
         if (node.attributes) {
             writePunctuation(",");
             writeSpace();
             writePunctuation("{");
             writeSpace();
-            writeKeyword("with");
+            emitTokenWithComment(node.attributes.attributes.token, node.pos, writeKeyword, node);
             writePunctuation(":");
             writeSpace();
             const elements = node.attributes.attributes.elements;
@@ -4009,8 +3990,8 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri
             writeSpace();
         }
         emitExpression(node.moduleSpecifier);
-        if (node.attributes || node.assertClause) {
-            emitWithLeadingSpace(node.attributes || node.assertClause);
+        if (node.attributes) {
+            emitWithLeadingSpace(node.attributes);
         }
         writeTrailingSemicolon();
     }
@@ -4084,35 +4065,14 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri
             writeSpace();
             emitExpression(node.moduleSpecifier);
         }
-        if (node.attributes || node.assertClause) {
-            emitWithLeadingSpace(node.attributes || node.assertClause);
+        if (node.attributes) {
+            emitWithLeadingSpace(node.attributes);
         }
         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 emitImportAttributes(node: ImportAttributes) {
-        emitTokenWithComment(SyntaxKind.WithKeyword, node.pos, writeKeyword, node);
+        emitTokenWithComment(node.token, node.pos, writeKeyword, node);
         writeSpace();
         const elements = node.elements;
         emitList(node, elements, ListFormat.ImportAttributes);

src/compiler/factory/nodeFactory.ts

@@ -2651,18 +2651,18 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
     }
 
     // @api
+    function createImportTypeNode(argument: TypeNode, assertions?: ImportTypeAssertionContainer, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode;
+    function createImportTypeNode(argument: TypeNode, attributes?: ImportTypeAttributes, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode;
     function createImportTypeNode(
         argument: TypeNode,
-        assertions?: ImportTypeAssertionContainer,
-        attributes?: ImportTypeAttributes,
+        attributes?: ImportTypeAssertionContainer | ImportTypeAttributes,
         qualifier?: EntityName,
         typeArguments?: readonly TypeNode[],
         isTypeOf = false,
     ): ImportTypeNode {
         const node = createBaseNode<ImportTypeNode>(SyntaxKind.ImportType);
         node.argument = argument;
-        node.assertions = assertions;
-        node.attributes = attributes;
+        node.attributes = node.assertions = attributes;
         node.qualifier = qualifier;
         node.typeArguments = typeArguments && parenthesizerRules().parenthesizeTypeArguments(typeArguments);
         node.isTypeOf = isTypeOf;
@@ -2671,22 +2671,23 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
     }
 
     // @api
+    function updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, assertions: ImportTypeAssertionContainer | undefined, qualifier: EntityName | undefined, typeArguments: readonly TypeNode[] | undefined, isTypeOf?: boolean | undefined): ImportTypeNode;
+    function updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, attributes: ImportTypeAttributes | undefined, qualifier: EntityName | undefined, typeArguments: readonly TypeNode[] | undefined, isTypeOf?: boolean | undefined): ImportTypeNode;
     function updateImportTypeNode(
         node: ImportTypeNode,
         argument: TypeNode,
-        assertions: ImportTypeAssertionContainer | undefined,
-        attributes: ImportTypeAttributes | undefined,
+        attributes: ImportTypeAssertionContainer | ImportTypeAttributes | undefined,
         qualifier: EntityName | undefined,
         typeArguments: readonly TypeNode[] | undefined,
         isTypeOf: boolean = node.isTypeOf,
     ): ImportTypeNode {
         return node.argument !== argument
-                || node.assertions !== assertions
+                || node.assertions !== attributes
                 || node.attributes !== attributes
                 || node.qualifier !== qualifier
                 || node.typeArguments !== typeArguments
                 || node.isTypeOf !== isTypeOf
-            ? update(createImportTypeNode(argument, assertions, attributes, qualifier, typeArguments, isTypeOf), node)
+            ? update(createImportTypeNode(argument, attributes, qualifier, typeArguments, isTypeOf), node)
             : node;
     }
 
@@ -4710,15 +4711,13 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
         modifiers: readonly ModifierLike[] | undefined,
         importClause: ImportClause | undefined,
         moduleSpecifier: Expression,
-        assertClause: AssertClause | undefined,
-        attributes: ImportAttributes | undefined,
+        attributes: ImportAttributes | AssertClause | undefined,
     ): ImportDeclaration {
         const node = createBaseNode<ImportDeclaration>(SyntaxKind.ImportDeclaration);
         node.modifiers = asNodeArray(modifiers);
         node.importClause = importClause;
         node.moduleSpecifier = moduleSpecifier;
-        node.assertClause = assertClause;
-        node.attributes = attributes;
+        node.attributes = node.assertClause = attributes;
         node.transformFlags |= propagateChildFlags(node.importClause) |
             propagateChildFlags(node.moduleSpecifier);
         node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // always parsed in an Await context
@@ -4733,15 +4732,13 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
         modifiers: readonly ModifierLike[] | undefined,
         importClause: ImportClause | undefined,
         moduleSpecifier: Expression,
-        assertClause: AssertClause | undefined,
-        attributes: ImportAttributes | undefined,
+        attributes: ImportAttributes | AssertClause | undefined,
     ) {
         return node.modifiers !== modifiers
                 || node.importClause !== importClause
                 || node.moduleSpecifier !== moduleSpecifier
-                || node.assertClause !== assertClause
                 || node.attributes !== attributes
-            ? update(createImportDeclaration(modifiers, importClause, moduleSpecifier, assertClause, attributes), node)
+            ? update(createImportDeclaration(modifiers, importClause, moduleSpecifier, attributes), node)
             : node;
     }
 
@@ -4774,6 +4771,7 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
         const node = createBaseNode<AssertClause>(SyntaxKind.AssertClause);
         node.elements = createNodeArray(elements);
         node.multiLine = multiLine;
+        node.token = SyntaxKind.AssertKeyword;
         node.transformFlags |= TransformFlags.ContainsESNext;
         return node;
     }
@@ -4822,7 +4820,7 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
     // @api
     function createImportTypeAttributes(attributes: ImportAttributes, multiLine?: boolean): ImportTypeAttributes {
         const node = createBaseNode<ImportTypeAttributes>(SyntaxKind.ImportTypeAttributes);
-        node.attributes = attributes;
+        node.attributes = node.assertClause = attributes;
         node.multiLine = multiLine;
         return node;
     }
@@ -4836,8 +4834,9 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
     }
 
     // @api
-    function createImportAttributes(elements: readonly ImportAttribute[], multiLine?: boolean): ImportAttributes {
+    function createImportAttributes(token: ImportAttributes["token"], elements: readonly ImportAttribute[], multiLine?: boolean): ImportAttributes {
         const node = createBaseNode<ImportAttributes>(SyntaxKind.ImportAttributes);
+        node.token = token;
         node.elements = createNodeArray(elements);
         node.multiLine = multiLine;
         node.transformFlags |= TransformFlags.ContainsESNext;
@@ -4848,7 +4847,7 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
     function updateImportAttributes(node: ImportAttributes, elements: readonly ImportAttribute[], multiLine?: boolean): ImportAttributes {
         return node.elements !== elements
                 || node.multiLine !== multiLine
-            ? update(createImportAttributes(elements, multiLine), node)
+            ? update(createImportAttributes(node.token, elements, multiLine), node)
             : node;
     }
 
@@ -4976,16 +4975,14 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
         isTypeOnly: boolean,
         exportClause: NamedExportBindings | undefined,
         moduleSpecifier?: Expression,
-        assertClause?: AssertClause,
-        attributes?: ImportAttributes,
+        attributes?: AssertClause | ImportAttributes,
     ) {
         const node = createBaseDeclaration<ExportDeclaration>(SyntaxKind.ExportDeclaration);
         node.modifiers = asNodeArray(modifiers);
         node.isTypeOnly = isTypeOnly;
         node.exportClause = exportClause;
         node.moduleSpecifier = moduleSpecifier;
-        node.assertClause = assertClause;
-        node.attributes = attributes;
+        node.attributes = node.assertClause = attributes;
         node.transformFlags |= propagateChildrenFlags(node.modifiers) |
             propagateChildFlags(node.exportClause) |
             propagateChildFlags(node.moduleSpecifier);
@@ -5002,16 +4999,14 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
         isTypeOnly: boolean,
         exportClause: NamedExportBindings | undefined,
         moduleSpecifier: Expression | undefined,
-        assertClause: AssertClause | undefined,
-        attributes: ImportAttributes | undefined,
+        attributes: AssertClause | ImportAttributes | undefined,
     ) {
         return node.modifiers !== modifiers
                 || node.isTypeOnly !== isTypeOnly
                 || node.exportClause !== exportClause
                 || node.moduleSpecifier !== moduleSpecifier
-                || node.assertClause !== assertClause
                 || node.attributes !== attributes
-            ? finishUpdateExportDeclaration(createExportDeclaration(modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause, attributes), node)
+            ? finishUpdateExportDeclaration(createExportDeclaration(modifiers, isTypeOnly, exportClause, moduleSpecifier, attributes), node)
             : node;
     }
 
@@ -7156,9 +7151,9 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
             isEnumDeclaration(node) ? updateEnumDeclaration(node, modifierArray, node.name, node.members) :
             isModuleDeclaration(node) ? updateModuleDeclaration(node, modifierArray, node.name, node.body) :
             isImportEqualsDeclaration(node) ? updateImportEqualsDeclaration(node, modifierArray, node.isTypeOnly, node.name, node.moduleReference) :
-            isImportDeclaration(node) ? updateImportDeclaration(node, modifierArray, node.importClause, node.moduleSpecifier, node.assertClause, node.attributes) :
+            isImportDeclaration(node) ? updateImportDeclaration(node, modifierArray, node.importClause, node.moduleSpecifier, node.attributes) :
             isExportAssignment(node) ? updateExportAssignment(node, modifierArray, node.expression) :
-            isExportDeclaration(node) ? updateExportDeclaration(node, modifierArray, node.isTypeOnly, node.exportClause, node.moduleSpecifier, node.assertClause, node.attributes) :
+            isExportDeclaration(node) ? updateExportDeclaration(node, modifierArray, node.isTypeOnly, node.exportClause, node.moduleSpecifier, node.attributes) :
             Debug.assertNever(node);
     }
 

src/compiler/factory/utilities.ts

@@ -754,7 +754,6 @@ export function createExternalHelpersImportDeclarationIfNeeded(nodeFactory: Node
                 /*modifiers*/ undefined,
                 nodeFactory.createImportClause(/*isTypeOnly*/ false, /*name*/ undefined, namedBindings),
                 nodeFactory.createStringLiteral(externalHelpersModuleNameText),
-                /*assertClause*/ undefined,
                 /*attributes*/ undefined,
             );
             addInternalEmitFlags(externalHelpersImportDeclaration, InternalEmitFlags.NeverApplyImportHelper);