@typescript-deploys/pr-build 4.6.0-pr-47552-4 → 4.6.0-pr-47548-5

package/lib/lib.es5.d.ts

@@ -1625,6 +1625,11 @@ type Uncapitalize<S extends string> = intrinsic;
  */
 interface ThisType<T> { }
 
+/**
+ * Marker for yield expressions return types
+ */
+interface YieldType<T> { }
+
 /**
  * Represents a raw buffer of binary data, which is used to store data for the
  * different typed arrays. ArrayBuffers cannot be read from or written to directly,

package/lib/tsc.js

@@ -69,7 +69,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 var ts;
 (function (ts) {
     ts.versionMajorMinor = "4.6";
-    ts.version = ts.versionMajorMinor + ".0-insiders.20220122";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220124";
     var NativeCollections;
     (function (NativeCollections) {
         function tryGetNativeMap() {
@@ -6681,8 +6681,6 @@ var ts;
         Remove_unused_declarations_for_Colon_0: diag(90041, ts.DiagnosticCategory.Message, "Remove_unused_declarations_for_Colon_0_90041", "Remove unused declarations for: '{0}'"),
         Declare_a_private_field_named_0: diag(90053, ts.DiagnosticCategory.Message, "Declare_a_private_field_named_0_90053", "Declare a private field named '{0}'."),
         Includes_imports_of_types_referenced_by_0: diag(90054, ts.DiagnosticCategory.Message, "Includes_imports_of_types_referenced_by_0_90054", "Includes imports of types referenced by '{0}'"),
-        Remove_type_from_import_declaration_from_0: diag(90055, ts.DiagnosticCategory.Message, "Remove_type_from_import_declaration_from_0_90055", "Remove 'type' from import declaration from \"{0}\""),
-        Remove_type_from_import_of_0_from_1: diag(90056, ts.DiagnosticCategory.Message, "Remove_type_from_import_of_0_from_1_90056", "Remove 'type' from import of '{0}' from \"{1}\""),
         Convert_function_to_an_ES2015_class: diag(95001, ts.DiagnosticCategory.Message, "Convert_function_to_an_ES2015_class_95001", "Convert function to an ES2015 class"),
         Convert_0_to_1_in_0: diag(95003, ts.DiagnosticCategory.Message, "Convert_0_to_1_in_0_95003", "Convert '{0}' to '{1} in {0}'"),
         Extract_to_0_in_1: diag(95004, ts.DiagnosticCategory.Message, "Extract_to_0_in_1_95004", "Extract to {0} in {1}"),
@@ -38905,6 +38903,7 @@ var ts;
         var globalBooleanType;
         var globalRegExpType;
         var globalThisType;
+        var globalYieldType;
         var anyArrayType;
         var autoArrayType;
         var anyReadonlyArrayType;
@@ -58928,6 +58927,14 @@ var ts;
                 return t.flags & 2097152 ? ts.forEach(t.types, getThisTypeArgument) : getThisTypeArgument(t);
             });
         }
+        function getYieldTypeArgument(type) {
+            return ts.getObjectFlags(type) & 4 && type.target === globalYieldType ? getTypeArguments(type)[0] : undefined;
+        }
+        function getYieldTypeFromContextualType(type) {
+            return mapType(type, function (t) {
+                return t.flags & 2097152 ? ts.forEach(t.types, getYieldTypeArgument) : getYieldTypeArgument(t);
+            });
+        }
         function getContextualThisParameterType(func) {
             if (func.kind === 213) {
                 return undefined;
@@ -64938,6 +64945,10 @@ var ts;
                 return getIterationTypeOfIterable(use, 1, yieldExpressionType, node.expression)
                     || anyType;
             }
+            var suggestedReturnType = yieldedType && getYieldTypeFromContextualType(yieldedType);
+            if (suggestedReturnType) {
+                return suggestedReturnType;
+            }
             else if (returnType) {
                 return getIterationTypeOfGeneratorFunctionReturnType(2, returnType, isAsync)
                     || anyType;
@@ -71729,6 +71740,7 @@ var ts;
             globalReadonlyArrayType = getGlobalTypeOrUndefined("ReadonlyArray", 1) || globalArrayType;
             anyReadonlyArrayType = globalReadonlyArrayType ? createTypeFromGenericGlobalType(globalReadonlyArrayType, [anyType]) : anyArrayType;
             globalThisType = getGlobalTypeOrUndefined("ThisType", 1);
+            globalYieldType = getGlobalTypeOrUndefined("YieldType", 1);
             if (augmentations) {
                 for (var _h = 0, augmentations_2 = augmentations; _h < augmentations_2.length; _h++) {
                     var list = augmentations_2[_h];

package/lib/tsserver.js

@@ -100,7 +100,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-insiders.20220122";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220124";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -9467,8 +9467,6 @@ var ts;
         Remove_unused_declarations_for_Colon_0: diag(90041, ts.DiagnosticCategory.Message, "Remove_unused_declarations_for_Colon_0_90041", "Remove unused declarations for: '{0}'"),
         Declare_a_private_field_named_0: diag(90053, ts.DiagnosticCategory.Message, "Declare_a_private_field_named_0_90053", "Declare a private field named '{0}'."),
         Includes_imports_of_types_referenced_by_0: diag(90054, ts.DiagnosticCategory.Message, "Includes_imports_of_types_referenced_by_0_90054", "Includes imports of types referenced by '{0}'"),
-        Remove_type_from_import_declaration_from_0: diag(90055, ts.DiagnosticCategory.Message, "Remove_type_from_import_declaration_from_0_90055", "Remove 'type' from import declaration from \"{0}\""),
-        Remove_type_from_import_of_0_from_1: diag(90056, ts.DiagnosticCategory.Message, "Remove_type_from_import_of_0_from_1_90056", "Remove 'type' from import of '{0}' from \"{1}\""),
         Convert_function_to_an_ES2015_class: diag(95001, ts.DiagnosticCategory.Message, "Convert_function_to_an_ES2015_class_95001", "Convert function to an ES2015 class"),
         Convert_0_to_1_in_0: diag(95003, ts.DiagnosticCategory.Message, "Convert_0_to_1_in_0_95003", "Convert '{0}' to '{1} in {0}'"),
         Extract_to_0_in_1: diag(95004, ts.DiagnosticCategory.Message, "Extract_to_0_in_1_95004", "Extract to {0} in {1}"),
@@ -47509,6 +47507,7 @@ var ts;
         var globalBooleanType;
         var globalRegExpType;
         var globalThisType;
+        var globalYieldType;
         var anyArrayType;
         var autoArrayType;
         var anyReadonlyArrayType;
@@ -70601,6 +70600,14 @@ var ts;
                 return t.flags & 2097152 /* Intersection */ ? ts.forEach(t.types, getThisTypeArgument) : getThisTypeArgument(t);
             });
         }
+        function getYieldTypeArgument(type) {
+            return ts.getObjectFlags(type) & 4 /* Reference */ && type.target === globalYieldType ? getTypeArguments(type)[0] : undefined;
+        }
+        function getYieldTypeFromContextualType(type) {
+            return mapType(type, function (t) {
+                return t.flags & 2097152 /* Intersection */ ? ts.forEach(t.types, getYieldTypeArgument) : getYieldTypeArgument(t);
+            });
+        }
         function getContextualThisParameterType(func) {
             if (func.kind === 213 /* ArrowFunction */) {
                 return undefined;
@@ -77544,6 +77551,10 @@ var ts;
                 return getIterationTypeOfIterable(use, 1 /* Return */, yieldExpressionType, node.expression)
                     || anyType;
             }
+            var suggestedReturnType = yieldedType && getYieldTypeFromContextualType(yieldedType);
+            if (suggestedReturnType) {
+                return suggestedReturnType;
+            }
             else if (returnType) {
                 return getIterationTypeOfGeneratorFunctionReturnType(2 /* Next */, returnType, isAsync)
                     || anyType;
@@ -85482,6 +85493,7 @@ var ts;
             globalReadonlyArrayType = getGlobalTypeOrUndefined("ReadonlyArray", /*arity*/ 1) || globalArrayType;
             anyReadonlyArrayType = globalReadonlyArrayType ? createTypeFromGenericGlobalType(globalReadonlyArrayType, [anyType]) : anyArrayType;
             globalThisType = getGlobalTypeOrUndefined("ThisType", /*arity*/ 1);
+            globalYieldType = getGlobalTypeOrUndefined("YieldType", /*arity*/ 1);
             if (augmentations) {
                 // merge _nonglobal_ module augmentations.
                 // this needs to be done after global symbol table is initialized to make sure that all ambient modules are indexed
@@ -128962,8 +128974,6 @@ var ts;
             CompletionSource["ThisProperty"] = "ThisProperty/";
             /** Auto-import that comes attached to a class member snippet */
             CompletionSource["ClassMemberSnippet"] = "ClassMemberSnippet/";
-            /** A type-only import that needs to be promoted in order to be used at the completion location */
-            CompletionSource["TypeOnlyAlias"] = "TypeOnlyAlias/";
         })(CompletionSource = Completions.CompletionSource || (Completions.CompletionSource = {}));
         var SymbolOriginInfoKind;
         (function (SymbolOriginInfoKind) {
@@ -128973,7 +128983,6 @@ var ts;
             SymbolOriginInfoKind[SymbolOriginInfoKind["Promise"] = 8] = "Promise";
             SymbolOriginInfoKind[SymbolOriginInfoKind["Nullable"] = 16] = "Nullable";
             SymbolOriginInfoKind[SymbolOriginInfoKind["ResolvedExport"] = 32] = "ResolvedExport";
-            SymbolOriginInfoKind[SymbolOriginInfoKind["TypeOnlyAlias"] = 64] = "TypeOnlyAlias";
             SymbolOriginInfoKind[SymbolOriginInfoKind["SymbolMemberNoExport"] = 2] = "SymbolMemberNoExport";
             SymbolOriginInfoKind[SymbolOriginInfoKind["SymbolMemberExport"] = 6] = "SymbolMemberExport";
         })(SymbolOriginInfoKind || (SymbolOriginInfoKind = {}));
@@ -129001,9 +129010,6 @@ var ts;
         function originIsNullableMember(origin) {
             return !!(origin.kind & 16 /* Nullable */);
         }
-        function originIsTypeOnlyAlias(origin) {
-            return !!(origin && origin.kind & 64 /* TypeOnlyAlias */);
-        }
         var KeywordCompletionFilters;
         (function (KeywordCompletionFilters) {
             KeywordCompletionFilters[KeywordCompletionFilters["None"] = 0] = "None";
@@ -129408,9 +129414,6 @@ var ts;
                     isSnippet = preferences.includeCompletionsWithSnippetText ? true : undefined;
                 }
             }
-            if ((origin === null || origin === void 0 ? void 0 : origin.kind) === 64 /* TypeOnlyAlias */) {
-                hasAction = true;
-            }
             if (preferences.includeCompletionsWithClassMemberSnippets &&
                 preferences.includeCompletionsWithInsertText &&
                 completionKind === 3 /* MemberLike */ &&
@@ -129755,9 +129758,6 @@ var ts;
             if ((origin === null || origin === void 0 ? void 0 : origin.kind) === 1 /* ThisType */) {
                 return CompletionSource.ThisProperty;
             }
-            if ((origin === null || origin === void 0 ? void 0 : origin.kind) === 64 /* TypeOnlyAlias */) {
-                return CompletionSource.TypeOnlyAlias;
-            }
         }
         function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, contextToken, location, sourceFile, host, program, target, log, kind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap, isJsxIdentifierExpected, isRightOfOpenTag) {
             var _a;
@@ -129785,7 +129785,7 @@ var ts;
                     continue;
                 }
                 /** True for locals; false for globals, module exports from other files, `this.` completions. */
-                var shouldShadowLaterSymbols = (!origin || originIsTypeOnlyAlias(origin)) && !(symbol.parent === undefined && !ts.some(symbol.declarations, function (d) { return d.getSourceFile() === location.getSourceFile(); }));
+                var shouldShadowLaterSymbols = !origin && !(symbol.parent === undefined && !ts.some(symbol.declarations, function (d) { return d.getSourceFile() === location.getSourceFile(); }));
                 uniques.set(name, shouldShadowLaterSymbols);
                 ts.insertSorted(entries, entry, compareCompletionEntries, /*allowDuplicates*/ true);
             }
@@ -129798,7 +129798,6 @@ var ts;
                 add: function (name) { return uniques.set(name, true); },
             };
             function shouldIncludeSymbol(symbol, symbolToSortTextIdMap) {
-                var allFlags = symbol.flags;
                 if (!ts.isSourceFile(location)) {
                     // export = /**/ here we want to get all meanings, so any symbol is ok
                     if (ts.isExportAssignment(location.parent)) {
@@ -129824,10 +129823,11 @@ var ts;
                             || symbolToSortTextIdMap[ts.getSymbolId(symbolOrigin)] === 11 /* LocationPriority */)) {
                         return false;
                     }
-                    allFlags |= ts.getCombinedLocalAndExportSymbolFlags(symbolOrigin);
+                    // Continue with origin symbol
+                    symbol = symbolOrigin;
                     // import m = /**/ <-- It can only access namespace (if typing import = x. this would get member symbols and not namespace)
                     if (ts.isInRightSideOfInternalImportEqualsDeclaration(location)) {
-                        return !!(allFlags & 1920 /* Namespace */);
+                        return !!(symbol.flags & 1920 /* Namespace */);
                     }
                     if (isTypeOnlyLocation) {
                         // It's a type, but you can reach it by namespace.type as well
@@ -129835,7 +129835,7 @@ var ts;
                     }
                 }
                 // expressions are value space (which includes the value namespaces)
-                return !!(allFlags & 111551 /* Value */);
+                return !!(ts.getCombinedLocalAndExportSymbolFlags(symbol) & 111551 /* Value */);
             }
         }
         Completions.getCompletionEntriesFromSymbols = getCompletionEntriesFromSymbols;
@@ -129988,11 +129988,6 @@ var ts;
                     };
                 }
             }
-            if (originIsTypeOnlyAlias(origin)) {
-                var codeAction_1 = ts.codefix.getPromoteTypeOnlyCompletionAction(sourceFile, origin.declaration.name, program, host, formatContext, preferences);
-                ts.Debug.assertIsDefined(codeAction_1, "Expected to have a code action for promoting type-only alias");
-                return { codeActions: [codeAction_1], sourceDisplay: undefined };
-            }
             if (!origin || !(originIsExport(origin) || originIsResolvedExport(origin))) {
                 return { codeActions: undefined, sourceDisplay: undefined };
             }
@@ -130669,29 +130664,21 @@ var ts;
                 var scopeNode = getScopeNode(contextToken, adjustedPosition, sourceFile) || sourceFile;
                 isInSnippetScope = isSnippetScope(scopeNode);
                 var symbolMeanings = (isTypeOnlyLocation ? 0 /* None */ : 111551 /* Value */) | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */;
-                var typeOnlyAliasNeedsPromotion = previousToken && !ts.isValidTypeOnlyAliasUseSite(previousToken);
                 symbols = ts.concatenate(symbols, typeChecker.getSymbolsInScope(scopeNode, symbolMeanings));
                 ts.Debug.assertEachIsDefined(symbols, "getSymbolsInScope() should all be defined");
-                for (var i = 0; i < symbols.length; i++) {
-                    var symbol = symbols[i];
+                for (var _i = 0, symbols_1 = symbols; _i < symbols_1.length; _i++) {
+                    var symbol = symbols_1[_i];
                     if (!typeChecker.isArgumentsSymbol(symbol) &&
                         !ts.some(symbol.declarations, function (d) { return d.getSourceFile() === sourceFile; })) {
                         symbolToSortTextIdMap[ts.getSymbolId(symbol)] = 15 /* GlobalsOrKeywords */;
                     }
-                    if (typeOnlyAliasNeedsPromotion && !(symbol.flags & 111551 /* Value */)) {
-                        var typeOnlyAliasDeclaration = symbol.declarations && ts.find(symbol.declarations, ts.isTypeOnlyImportOrExportDeclaration);
-                        if (typeOnlyAliasDeclaration) {
-                            var origin = { kind: 64 /* TypeOnlyAlias */, declaration: typeOnlyAliasDeclaration };
-                            symbolToOriginInfoMap[i] = origin;
-                        }
-                    }
                 }
                 // Need to insert 'this.' before properties of `this` type, so only do that if `includeInsertTextCompletions`
                 if (preferences.includeCompletionsWithInsertText && scopeNode.kind !== 303 /* SourceFile */) {
                     var thisType = typeChecker.tryGetThisTypeAt(scopeNode, /*includeGlobalThis*/ false);
                     if (thisType && !isProbablyGlobalType(thisType, sourceFile, typeChecker)) {
-                        for (var _i = 0, _a = getPropertiesForCompletion(thisType, typeChecker); _i < _a.length; _i++) {
-                            var symbol = _a[_i];
+                        for (var _a = 0, _b = getPropertiesForCompletion(thisType, typeChecker); _a < _b.length; _a++) {
+                            var symbol = _b[_a];
                             symbolToOriginInfoMap[symbols.length] = { kind: 1 /* ThisType */ };
                             symbols.push(symbol);
                             symbolToSortTextIdMap[ts.getSymbolId(symbol)] = 14 /* SuggestedClassMembers */;
@@ -132090,14 +132077,10 @@ var ts;
         /** True if symbol is a type or a module containing at least one type. */
         function symbolCanBeReferencedAtTypeLocation(symbol, checker, seenModules) {
             if (seenModules === void 0) { seenModules = new ts.Map(); }
-            // Since an alias can be merged with a local declaration, we need to test both the alias and its target.
-            // This code used to just test the result of `skipAlias`, but that would ignore any locally introduced meanings.
-            return nonAliasCanBeReferencedAtTypeLocation(symbol) || nonAliasCanBeReferencedAtTypeLocation(ts.skipAlias(symbol.exportSymbol || symbol, checker));
-            function nonAliasCanBeReferencedAtTypeLocation(symbol) {
-                return !!(symbol.flags & 788968 /* Type */) || checker.isUnknownSymbol(symbol) ||
-                    !!(symbol.flags & 1536 /* Module */) && ts.addToSeen(seenModules, ts.getSymbolId(symbol)) &&
-                        checker.getExportsOfModule(symbol).some(function (e) { return symbolCanBeReferencedAtTypeLocation(e, checker, seenModules); });
-            }
+            var sym = ts.skipAlias(symbol.exportSymbol || symbol, checker);
+            return !!(sym.flags & 788968 /* Type */) || checker.isUnknownSymbol(sym) ||
+                !!(sym.flags & 1536 /* Module */) && ts.addToSeen(seenModules, ts.getSymbolId(sym)) &&
+                    checker.getExportsOfModule(sym).some(function (e) { return symbolCanBeReferencedAtTypeLocation(e, checker, seenModules); });
         }
         function isDeprecated(symbol, checker) {
             var declarations = ts.skipAlias(symbol, checker).declarations;
@@ -134351,8 +134334,8 @@ var ts;
                     var sourceId = ts.getNodeId(sourceFile);
                     var seenSymbols = this.sourceFileToSeenSymbols[sourceId] || (this.sourceFileToSeenSymbols[sourceId] = new ts.Set());
                     var anyNewSymbols = false;
-                    for (var _i = 0, symbols_1 = symbols; _i < symbols_1.length; _i++) {
-                        var sym = symbols_1[_i];
+                    for (var _i = 0, symbols_2 = symbols; _i < symbols_2.length; _i++) {
+                        var sym = symbols_2[_i];
                         anyNewSymbols = ts.tryAddToSet(seenSymbols, ts.getSymbolId(sym)) || anyNewSymbols;
                     }
                     return anyNewSymbols;
@@ -145204,7 +145187,6 @@ var ts;
             ChangeTracker.prototype.delete = function (sourceFile, node) {
                 this.deletedNodes.push({ sourceFile: sourceFile, node: node });
             };
-            /** Stop! Consider using `delete` instead, which has logic for deleting nodes from delimited lists. */
             ChangeTracker.prototype.deleteNode = function (sourceFile, node, options) {
                 if (options === void 0) { options = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }; }
                 this.deleteRange(sourceFile, getAdjustedRange(sourceFile, node, node, options));
@@ -145608,15 +145590,6 @@ var ts;
             ChangeTracker.prototype.insertExportModifier = function (sourceFile, node) {
                 this.insertText(sourceFile, node.getStart(sourceFile), "export ");
             };
-            ChangeTracker.prototype.insertImportSpecifierAtIndex = function (sourceFile, importSpecifier, namedImports, index) {
-                var prevSpecifier = namedImports.elements[index - 1];
-                if (prevSpecifier) {
-                    this.insertNodeInListAfter(sourceFile, prevSpecifier, importSpecifier);
-                }
-                else {
-                    this.insertNodeBefore(sourceFile, namedImports.elements[0], importSpecifier, !ts.positionsAreOnSameLine(namedImports.elements[0].getStart(), namedImports.parent.parent.getStart(), sourceFile));
-                }
-            };
             /**
              * This function should be used to insert nodes in lists when nodes don't carry separators as the part of the node range,
              * i.e. arguments in arguments lists, parameters in parameter lists etc.
@@ -149119,8 +149092,7 @@ var ts;
             ts.Diagnostics.Cannot_find_namespace_0.code,
             ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code,
             ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here.code,
-            ts.Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer.code,
-            ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type.code,
+            ts.Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer.code
         ];
         codefix.registerCodeFix({
             errorCodes: errorCodes,
@@ -149225,9 +149197,6 @@ var ts;
                         }
                         break;
                     }
-                    case 4 /* PromoteTypeOnly */:
-                        // Excluding from fix-all
-                        break;
                     default:
                         ts.Debug.assertNever(fix, "fix wasn't never - got kind " + fix.kind);
                 }
@@ -149319,7 +149288,6 @@ var ts;
             ImportFixKind[ImportFixKind["JsdocTypeImport"] = 1] = "JsdocTypeImport";
             ImportFixKind[ImportFixKind["AddToExisting"] = 2] = "AddToExisting";
             ImportFixKind[ImportFixKind["AddNew"] = 3] = "AddNew";
-            ImportFixKind[ImportFixKind["PromoteTypeOnly"] = 4] = "PromoteTypeOnly";
         })(ImportFixKind || (ImportFixKind = {}));
         // These should not be combined as bitflags, but are given powers of 2 values to
         // easily detect conflicts between `NotAllowed` and `Required` by giving them a unique sum.
@@ -149345,13 +149313,6 @@ var ts;
             };
         }
         codefix.getImportCompletionAction = getImportCompletionAction;
-        function getPromoteTypeOnlyCompletionAction(sourceFile, symbolToken, program, host, formatContext, preferences) {
-            var compilerOptions = program.getCompilerOptions();
-            var symbolName = getSymbolName(sourceFile, program.getTypeChecker(), symbolToken, compilerOptions);
-            var fix = getTypeOnlyPromotionFix(sourceFile, symbolToken, symbolName, program);
-            return fix && codeFixActionToCodeAction(codeActionForFix({ host: host, formatContext: formatContext, preferences: preferences }, sourceFile, symbolName, fix, 1 /* Double */, compilerOptions));
-        }
-        codefix.getPromoteTypeOnlyCompletionAction = getPromoteTypeOnlyCompletionAction;
         function getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences) {
             ts.Debug.assert(exportInfos.some(function (info) { return info.moduleSymbol === moduleSymbol || info.symbol.parent === moduleSymbol; }), "Some exportInfo should match the specified moduleSymbol");
             var packageJsonImportFilter = ts.createPackageJsonImportFilter(sourceFile, preferences, host);
@@ -149632,18 +149593,9 @@ var ts;
         }
         function getFixesInfo(context, errorCode, pos, useAutoImportProvider) {
             var symbolToken = ts.getTokenAtPosition(context.sourceFile, pos);
-            if (errorCode === ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code) {
-                return getFixesInfoForUMDImport(context, symbolToken);
-            }
-            if (!ts.isIdentifier(symbolToken)) {
-                return undefined;
-            }
-            if (errorCode === ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type.code) {
-                var symbolName_1 = getSymbolName(context.sourceFile, context.program.getTypeChecker(), symbolToken, context.program.getCompilerOptions());
-                var fix = getTypeOnlyPromotionFix(context.sourceFile, symbolToken, symbolName_1, context.program);
-                return fix && { fixes: [fix], symbolName: symbolName_1 };
-            }
-            var info = getFixesInfoForNonUMDImport(context, symbolToken, useAutoImportProvider);
+            var info = errorCode === ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code
+                ? getFixesInfoForUMDImport(context, symbolToken)
+                : ts.isIdentifier(symbolToken) ? getFixesInfoForNonUMDImport(context, symbolToken, useAutoImportProvider) : undefined;
             var packageJsonImportFilter = ts.createPackageJsonImportFilter(context.sourceFile, context.preferences, context.host);
             return info && __assign(__assign({}, info), { fixes: sortFixes(info.fixes, context.sourceFile, context.program, packageJsonImportFilter) });
         }
@@ -149767,16 +149719,6 @@ var ts;
             }));
             return { fixes: fixes, symbolName: symbolName };
         }
-        function getTypeOnlyPromotionFix(sourceFile, symbolToken, symbolName, program) {
-            var checker = program.getTypeChecker();
-            var symbol = checker.resolveName(symbolName, symbolToken, 111551 /* Value */, /*excludeGlobals*/ true);
-            if (!symbol)
-                return undefined;
-            var typeOnlyAliasDeclaration = checker.getTypeOnlyAliasDeclaration(symbol);
-            if (!typeOnlyAliasDeclaration || ts.getSourceFileOfNode(typeOnlyAliasDeclaration) !== sourceFile)
-                return undefined;
-            return { kind: 4 /* PromoteTypeOnly */, typeOnlyAliasDeclaration: typeOnlyAliasDeclaration };
-        }
         function jsxModeNeedsExplicitImport(jsx) {
             return jsx === 2 /* React */ || jsx === 3 /* ReactNative */;
         }
@@ -149784,18 +149726,12 @@ var ts;
             var parent = symbolToken.parent;
             if ((ts.isJsxOpeningLikeElement(parent) || ts.isJsxClosingElement(parent)) && parent.tagName === symbolToken && jsxModeNeedsExplicitImport(compilerOptions.jsx)) {
                 var jsxNamespace = checker.getJsxNamespace(sourceFile);
-                if (needsJsxNamespaceFix(jsxNamespace, symbolToken, checker)) {
+                if (ts.isIntrinsicJsxName(symbolToken.text) || !checker.resolveName(jsxNamespace, parent, 111551 /* Value */, /*excludeGlobals*/ true)) {
                     return jsxNamespace;
                 }
             }
             return symbolToken.text;
         }
-        function needsJsxNamespaceFix(jsxNamespace, symbolToken, checker) {
-            if (ts.isIntrinsicJsxName(symbolToken.text))
-                return true; // If we were triggered by a matching error code on an intrinsic, the error must have been about missing the JSX factory
-            var namespaceSymbol = checker.resolveName(jsxNamespace, symbolToken, 111551 /* Value */, /*excludeGlobals*/ true);
-            return !namespaceSymbol || ts.some(namespaceSymbol.declarations, ts.isTypeOnlyImportOrExportDeclaration) && !(namespaceSymbol.flags & 111551 /* Value */);
-        }
         // Returns a map from an exported symbol's ID to a list of every way it's (re-)exported.
         function getExportInfos(symbolName, currentTokenMeaning, cancellationToken, fromFile, program, useAutoImportProvider, host, preferences) {
             var _a;
@@ -149894,80 +149830,10 @@ var ts;
                     ts.insertImports(changes, sourceFile, getDeclarations(moduleSpecifier, quotePreference, defaultImport, namedImports, namespaceLikeImport), /*blankLineBetween*/ true);
                     return [importKind === 1 /* Default */ ? ts.Diagnostics.Import_default_0_from_module_1 : ts.Diagnostics.Import_0_from_module_1, symbolName, moduleSpecifier];
                 }
-                case 4 /* PromoteTypeOnly */: {
-                    var typeOnlyAliasDeclaration = fix.typeOnlyAliasDeclaration;
-                    var promotedDeclaration = promoteFromTypeOnly(changes, typeOnlyAliasDeclaration, compilerOptions, sourceFile);
-                    return promotedDeclaration.kind === 269 /* ImportSpecifier */
-                        ? [ts.Diagnostics.Remove_type_from_import_of_0_from_1, symbolName, getModuleSpecifierText(promotedDeclaration.parent.parent)]
-                        : [ts.Diagnostics.Remove_type_from_import_declaration_from_0, getModuleSpecifierText(promotedDeclaration)];
-                }
                 default:
                     return ts.Debug.assertNever(fix, "Unexpected fix kind " + fix.kind);
             }
         }
-        function getModuleSpecifierText(promotedDeclaration) {
-            var _a, _b;
-            return promotedDeclaration.kind === 264 /* ImportEqualsDeclaration */
-                ? ((_b = ts.tryCast((_a = ts.tryCast(promotedDeclaration.moduleReference, ts.isExternalModuleReference)) === null || _a === void 0 ? void 0 : _a.expression, ts.isStringLiteralLike)) === null || _b === void 0 ? void 0 : _b.text) || promotedDeclaration.moduleReference.getText()
-                : ts.cast(promotedDeclaration.parent.moduleSpecifier, ts.isStringLiteral).text;
-        }
-        function promoteFromTypeOnly(changes, aliasDeclaration, compilerOptions, sourceFile) {
-            // See comment in `doAddExistingFix` on constant with the same name.
-            var convertExistingToTypeOnly = compilerOptions.preserveValueImports && compilerOptions.isolatedModules;
-            switch (aliasDeclaration.kind) {
-                case 269 /* ImportSpecifier */:
-                    if (aliasDeclaration.isTypeOnly) {
-                        if (aliasDeclaration.parent.elements.length > 1 && ts.OrganizeImports.importSpecifiersAreSorted(aliasDeclaration.parent.elements)) {
-                            changes.delete(sourceFile, aliasDeclaration);
-                            var newSpecifier = ts.factory.updateImportSpecifier(aliasDeclaration, /*isTypeOnly*/ false, aliasDeclaration.propertyName, aliasDeclaration.name);
-                            var insertionIndex = ts.OrganizeImports.getImportSpecifierInsertionIndex(aliasDeclaration.parent.elements, newSpecifier);
-                            changes.insertImportSpecifierAtIndex(sourceFile, newSpecifier, aliasDeclaration.parent, insertionIndex);
-                        }
-                        else {
-                            changes.deleteRange(sourceFile, aliasDeclaration.getFirstToken());
-                        }
-                        return aliasDeclaration;
-                    }
-                    else {
-                        ts.Debug.assert(aliasDeclaration.parent.parent.isTypeOnly);
-                        promoteImportClause(aliasDeclaration.parent.parent);
-                        return aliasDeclaration.parent.parent;
-                    }
-                case 266 /* ImportClause */:
-                    promoteImportClause(aliasDeclaration);
-                    return aliasDeclaration;
-                case 267 /* NamespaceImport */:
-                    promoteImportClause(aliasDeclaration.parent);
-                    return aliasDeclaration.parent;
-                case 264 /* ImportEqualsDeclaration */:
-                    changes.deleteRange(sourceFile, aliasDeclaration.getChildAt(1));
-                    return aliasDeclaration;
-                default:
-                    ts.Debug.failBadSyntaxKind(aliasDeclaration);
-            }
-            function promoteImportClause(importClause) {
-                changes.delete(sourceFile, ts.getTypeKeywordOfTypeOnlyImport(importClause, sourceFile));
-                if (convertExistingToTypeOnly) {
-                    var namedImports = ts.tryCast(importClause.namedBindings, ts.isNamedImports);
-                    if (namedImports && namedImports.elements.length > 1) {
-                        if (ts.OrganizeImports.importSpecifiersAreSorted(namedImports.elements) &&
-                            aliasDeclaration.kind === 269 /* ImportSpecifier */ &&
-                            namedImports.elements.indexOf(aliasDeclaration) !== 0) {
-                            // The import specifier being promoted will be the only non-type-only,
-                            //  import in the NamedImports, so it should be moved to the front.
-                            changes.delete(sourceFile, aliasDeclaration);
-                            changes.insertImportSpecifierAtIndex(sourceFile, aliasDeclaration, namedImports, 0);
-                        }
-                        for (var _i = 0, _a = namedImports.elements; _i < _a.length; _i++) {
-                            var element = _a[_i];
-                            if (element !== aliasDeclaration && !element.isTypeOnly) {
-                                changes.insertModifierBefore(sourceFile, 151 /* TypeKeyword */, element);
-                            }
-                        }
-                    }
-                }
-            }
-        }
         function doAddExistingFix(changes, sourceFile, clause, defaultImport, namedImports, compilerOptions) {
             var _a;
             if (clause.kind === 200 /* ObjectBindingPattern */) {
@@ -150005,7 +149871,13 @@ var ts;
                         var insertionIndex = convertExistingToTypeOnly && !spec.isTypeOnly
                             ? 0
                             : ts.OrganizeImports.getImportSpecifierInsertionIndex(existingSpecifiers, spec);
-                        changes.insertImportSpecifierAtIndex(sourceFile, spec, clause.namedBindings, insertionIndex);
+                        var prevSpecifier = clause.namedBindings.elements[insertionIndex - 1];
+                        if (prevSpecifier) {
+                            changes.insertNodeInListAfter(sourceFile, prevSpecifier, spec);
+                        }
+                        else {
+                            changes.insertNodeBefore(sourceFile, existingSpecifiers[0], spec, !ts.positionsAreOnSameLine(existingSpecifiers[0].getStart(), clause.parent.getStart(), sourceFile));
+                        }
                     }
                 }
                 else if (existingSpecifiers === null || existingSpecifiers === void 0 ? void 0 : existingSpecifiers.length) {

package/lib/tsserverlibrary.d.ts

@@ -1720,23 +1720,19 @@ declare namespace ts {
         readonly parent: ImportClause & {
             readonly isTypeOnly: true;
         };
-    } | ImportSpecifier & ({
-        readonly isTypeOnly: true;
-    } | {
+    } | ImportSpecifier & {
         readonly parent: NamedImports & {
             readonly parent: ImportClause & {
                 readonly isTypeOnly: true;
             };
         };
-    }) | ExportSpecifier & ({
-        readonly isTypeOnly: true;
-    } | {
+    } | ExportSpecifier & {
         readonly parent: NamedExports & {
             readonly parent: ExportDeclaration & {
                 readonly isTypeOnly: true;
             };
         };
-    });
+    };
     /**
      * This is either an `export =` or an `export default` declaration.
      * Unless `isExportEquals` is set, this node was parsed as an `export default`.