Add nightly-only error on ImportType resolution mode assertion

src/compiler/checker.ts

@@ -6224,6 +6224,7 @@ namespace ts {
                                     factory.createStringLiteral("import")
                                 )
                             ])));
+                            context.tracker.reportImportTypeNodeResolutionModeOverride?.();
                         }
                     }
                     if (!specifier) {
@@ -6247,6 +6248,7 @@ namespace ts {
                                         factory.createStringLiteral(swappedMode === ModuleKind.ESNext ? "import" : "require")
                                     )
                                 ])));
+                                context.tracker.reportImportTypeNodeResolutionModeOverride?.();
                             }
                         }
 
@@ -36029,6 +36031,9 @@ namespace ts {
             if (node.assertions) {
                 const override = getResolutionModeOverrideForClause(node.assertions.assertClause, grammarErrorOnNode);
                 if (override) {
+                    if (!isNightly()) {
+                        grammarErrorOnNode(node.assertions.assertClause, Diagnostics.Resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next);
+                    }
                     if (getEmitModuleResolutionKind(compilerOptions) !== ModuleResolutionKind.Node16 && getEmitModuleResolutionKind(compilerOptions) !== ModuleResolutionKind.NodeNext) {
                         grammarErrorOnNode(node.assertions.assertClause, Diagnostics.Resolution_modes_are_only_supported_when_moduleResolution_is_node16_or_nodenext);
                     }

src/compiler/diagnosticMessages.json

@@ -3479,6 +3479,10 @@
         "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
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",

src/compiler/transformers/declarations.ts

@@ -78,7 +78,8 @@ namespace ts {
             trackReferencedAmbientModule,
             trackExternalModuleSymbolOfImportTypeNode,
             reportNonlocalAugmentation,
-            reportNonSerializableProperty
+            reportNonSerializableProperty,
+            reportImportTypeNodeResolutionModeOverride,
         };
         let errorNameNode: DeclarationName | undefined;
         let errorFallbackNode: Declaration | undefined;
@@ -235,6 +236,12 @@ namespace ts {
             }
         }
 
+        function reportImportTypeNodeResolutionModeOverride() {
+            if (!isNightly() && (errorNameNode || errorFallbackNode)) {
+                context.addDiagnostic(createDiagnosticForNode((errorNameNode || errorFallbackNode)!, Diagnostics.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));
+            }
+        }
+
         function transformDeclarationsForJS(sourceFile: SourceFile, bundled?: boolean) {
             const oldDiag = getSymbolAccessibilityDiagnostic;
             getSymbolAccessibilityDiagnostic = (s) => (s.errorNode && canProduceDiagnostics(s.errorNode) ? createGetSymbolAccessibilityDiagnosticForNode(s.errorNode)(s) : ({
@@ -788,13 +795,13 @@ namespace ts {
             // Nothing visible
         }
 
-        function getResolutionModeOverrideForClauseInNightly(assertClause: AssertClause | undefined) {
-            const mode = getResolutionModeOverrideForClause(assertClause);
+        function getResolutionModeOverrideForClauseInNightly<T extends AssertClause | ImportTypeAssertionContainer>(container: T | undefined): T | undefined {
+            const mode = getResolutionModeOverrideForClause(container?.kind === SyntaxKind.AssertClause ? container : container?.assertClause);
             if (mode !== undefined) {
                 if (!isNightly()) {
-                    context.addDiagnostic(createDiagnosticForNode(assertClause!, Diagnostics.Resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next));
+                    context.addDiagnostic(createDiagnosticForNode(container!, Diagnostics.Resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next));
                 }
-                return assertClause;
+                return container;
             }
             return undefined;
         }
@@ -1067,7 +1074,7 @@ namespace ts {
                         return cleanup(factory.updateImportTypeNode(
                             input,
                             factory.updateLiteralTypeNode(input.argument, rewriteModuleSpecifier(input, input.argument.literal)),
-                            input.assertions,
+                            getResolutionModeOverrideForClauseInNightly(input.assertions),
                             input.qualifier,
                             visitNodes(input.typeArguments, visitDeclarationSubtree, isTypeNode),
                             input.isTypeOf

src/compiler/types.ts

@@ -8524,6 +8524,7 @@ namespace ts {
         trackExternalModuleSymbolOfImportTypeNode?(symbol: Symbol): void;
         reportNonlocalAugmentation?(containingFile: SourceFile, parentSymbol: Symbol, augmentingSymbol: Symbol): void;
         reportNonSerializableProperty?(propertyName: string): void;
+        reportImportTypeNodeResolutionModeOverride?(): void;
     }
 
     export interface TextSpan {