typescript 4.9.0-dev.20220929 → 4.9.0-dev.20220930

package/lib/tsserverlibrary.js

@@ -108,7 +108,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 = "".concat(ts.versionMajorMinor, ".0-dev.20220929");
+    ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20220930");
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -49497,6 +49497,12 @@ var ts;
             getOptionalType: function () { return optionalType; },
             getPromiseType: function () { return getGlobalPromiseType(/*reportErrors*/ false); },
             getPromiseLikeType: function () { return getGlobalPromiseLikeType(/*reportErrors*/ false); },
+            getAsyncIterableType: function () {
+                var type = getGlobalAsyncIterableType(/*reportErrors*/ false);
+                if (type === emptyGenericType)
+                    return undefined;
+                return type;
+            },
             isSymbolAccessible: isSymbolAccessible,
             isArrayType: isArrayType,
             isTupleType: isTupleType,
@@ -50334,9 +50340,9 @@ var ts;
                         return symbol;
                     }
                     if (symbol.flags & 2097152 /* SymbolFlags.Alias */) {
-                        var target = resolveAlias(symbol);
-                        // Unknown symbol means an error occurred in alias resolution, treat it as positive answer to avoid cascading errors
-                        if (target === unknownSymbol || target.flags & meaning) {
+                        var targetFlags = getAllSymbolFlags(symbol);
+                        // `targetFlags` will be `SymbolFlags.All` if an error occurred in alias resolution; this avoids cascading errors
+                        if (targetFlags & meaning) {
                             return symbol;
                         }
                     }
@@ -50969,8 +50975,8 @@ var ts;
                                 !checkAndReportErrorForExtendingInterface(errorLocation) &&
                                 !checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) &&
                                 !checkAndReportErrorForExportingPrimitiveType(errorLocation, name) &&
+                                !checkAndReportErrorForUsingNamespaceAsTypeOrValue(errorLocation, name, meaning) &&
                                 !checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) &&
-                                !checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning) &&
                                 !checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning)) {
                             var suggestion = void 0;
                             var suggestedLib = void 0;
@@ -51057,7 +51063,7 @@ var ts;
                         }
                     }
                     if (result && errorLocation && meaning & 111551 /* SymbolFlags.Value */ && result.flags & 2097152 /* SymbolFlags.Alias */ && !(result.flags & 111551 /* SymbolFlags.Value */) && !ts.isValidTypeOnlyAliasUseSite(errorLocation)) {
-                        var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(result);
+                        var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(result, 111551 /* SymbolFlags.Value */);
                         if (typeOnlyDeclaration) {
                             var message = typeOnlyDeclaration.kind === 278 /* SyntaxKind.ExportSpecifier */
                                 ? ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type
@@ -51220,7 +51226,7 @@ var ts;
             return false;
         }
         function checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) {
-            if (meaning & (111551 /* SymbolFlags.Value */ & ~1024 /* SymbolFlags.NamespaceModule */)) {
+            if (meaning & 111551 /* SymbolFlags.Value */) {
                 if (isPrimitiveTypeName(name)) {
                     if (isExtendedByInterface(errorLocation)) {
                         error(errorLocation, ts.Diagnostics.An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_classes, ts.unescapeLeadingUnderscores(name));
@@ -51231,7 +51237,8 @@ var ts;
                     return true;
                 }
                 var symbol = resolveSymbol(resolveName(errorLocation, name, 788968 /* SymbolFlags.Type */ & ~111551 /* SymbolFlags.Value */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false));
-                if (symbol && !(symbol.flags & 1024 /* SymbolFlags.NamespaceModule */)) {
+                var allFlags = symbol && getAllSymbolFlags(symbol);
+                if (symbol && allFlags !== undefined && !(allFlags & 111551 /* SymbolFlags.Value */)) {
                     var rawName = ts.unescapeLeadingUnderscores(name);
                     if (isES2015OrLaterConstructorName(name)) {
                         error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later, rawName);
@@ -51279,16 +51286,16 @@ var ts;
             }
             return false;
         }
-        function checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning) {
-            if (meaning & (111551 /* SymbolFlags.Value */ & ~1024 /* SymbolFlags.NamespaceModule */ & ~788968 /* SymbolFlags.Type */)) {
-                var symbol = resolveSymbol(resolveName(errorLocation, name, 1024 /* SymbolFlags.NamespaceModule */ & ~111551 /* SymbolFlags.Value */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false));
+        function checkAndReportErrorForUsingNamespaceAsTypeOrValue(errorLocation, name, meaning) {
+            if (meaning & (111551 /* SymbolFlags.Value */ & ~788968 /* SymbolFlags.Type */)) {
+                var symbol = resolveSymbol(resolveName(errorLocation, name, 1024 /* SymbolFlags.NamespaceModule */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false));
                 if (symbol) {
                     error(errorLocation, ts.Diagnostics.Cannot_use_namespace_0_as_a_value, ts.unescapeLeadingUnderscores(name));
                     return true;
                 }
             }
-            else if (meaning & (788968 /* SymbolFlags.Type */ & ~1024 /* SymbolFlags.NamespaceModule */ & ~111551 /* SymbolFlags.Value */)) {
-                var symbol = resolveSymbol(resolveName(errorLocation, name, (512 /* SymbolFlags.ValueModule */ | 1024 /* SymbolFlags.NamespaceModule */) & ~788968 /* SymbolFlags.Type */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false));
+            else if (meaning & (788968 /* SymbolFlags.Type */ & ~111551 /* SymbolFlags.Value */)) {
+                var symbol = resolveSymbol(resolveName(errorLocation, name, 1536 /* SymbolFlags.Module */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false));
                 if (symbol) {
                     error(errorLocation, ts.Diagnostics.Cannot_use_namespace_0_as_a_type, ts.unescapeLeadingUnderscores(name));
                     return true;
@@ -51878,6 +51885,52 @@ var ts;
             }
             return undefined;
         }
+        /**
+         * Gets combined flags of a `symbol` and all alias targets it resolves to. `resolveAlias`
+         * is typically recursive over chains of aliases, but stops mid-chain if an alias is merged
+         * with another exported symbol, e.g.
+         * ```ts
+         * // a.ts
+         * export const a = 0;
+         * // b.ts
+         * export { a } from "./a";
+         * export type a = number;
+         * // c.ts
+         * import { a } from "./b";
+         * ```
+         * Calling `resolveAlias` on the `a` in c.ts would stop at the merged symbol exported
+         * from b.ts, even though there is still more alias to resolve. Consequently, if we were
+         * trying to determine if the `a` in c.ts has a value meaning, looking at the flags on
+         * the local symbol and on the symbol returned by `resolveAlias` is not enough.
+         * @returns SymbolFlags.All if `symbol` is an alias that ultimately resolves to `unknown`;
+         * combined flags of all alias targets otherwise.
+         */
+        function getAllSymbolFlags(symbol) {
+            var flags = symbol.flags;
+            var seenSymbols;
+            while (symbol.flags & 2097152 /* SymbolFlags.Alias */) {
+                var target = resolveAlias(symbol);
+                if (target === unknownSymbol) {
+                    return 67108863 /* SymbolFlags.All */;
+                }
+                // Optimizations - try to avoid creating or adding to
+                // `seenSymbols` if possible
+                if (target === symbol || (seenSymbols === null || seenSymbols === void 0 ? void 0 : seenSymbols.has(target))) {
+                    break;
+                }
+                if (target.flags & 2097152 /* SymbolFlags.Alias */) {
+                    if (seenSymbols) {
+                        seenSymbols.add(target);
+                    }
+                    else {
+                        seenSymbols = new ts.Set([symbol, target]);
+                    }
+                }
+                flags |= target.flags;
+                symbol = target;
+            }
+            return flags;
+        }
         /**
          * Marks a symbol as type-only if its declaration is syntactically type-only.
          * If it is not itself marked type-only, but resolves to a type-only alias
@@ -51923,19 +51976,25 @@ var ts;
             return !!aliasDeclarationLinks.typeOnlyDeclaration;
         }
         /** Indicates that a symbol directly or indirectly resolves to a type-only import or export. */
-        function getTypeOnlyAliasDeclaration(symbol) {
+        function getTypeOnlyAliasDeclaration(symbol, include) {
             if (!(symbol.flags & 2097152 /* SymbolFlags.Alias */)) {
                 return undefined;
             }
             var links = getSymbolLinks(symbol);
-            return links.typeOnlyDeclaration || undefined;
+            if (include === undefined) {
+                return links.typeOnlyDeclaration || undefined;
+            }
+            if (links.typeOnlyDeclaration) {
+                return getAllSymbolFlags(resolveAlias(links.typeOnlyDeclaration.symbol)) & include ? links.typeOnlyDeclaration : undefined;
+            }
+            return undefined;
         }
         function markExportAsReferenced(node) {
             var symbol = getSymbolOfNode(node);
             var target = resolveAlias(symbol);
             if (target) {
                 var markAlias = target === unknownSymbol ||
-                    ((target.flags & 111551 /* SymbolFlags.Value */) && !isConstEnumOrConstEnumOnlyModule(target) && !getTypeOnlyAliasDeclaration(symbol));
+                    ((getAllSymbolFlags(target) & 111551 /* SymbolFlags.Value */) && !isConstEnumOrConstEnumOnlyModule(target) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* SymbolFlags.Value */));
                 if (markAlias) {
                     markAliasSymbolAsReferenced(symbol);
                 }
@@ -51955,8 +52014,7 @@ var ts;
                 // This way a chain of imports can be elided if ultimately the final input is only used in a type
                 // position.
                 if (ts.isInternalModuleImportEqualsDeclaration(node)) {
-                    var target = resolveSymbol(symbol);
-                    if (target === unknownSymbol || target.flags & 111551 /* SymbolFlags.Value */) {
+                    if (getAllSymbolFlags(resolveSymbol(symbol)) & 111551 /* SymbolFlags.Value */) {
                         // import foo = <symbol>
                         checkExpressionCached(node.moduleReference);
                     }
@@ -52778,7 +52836,7 @@ var ts;
         }
         function symbolIsValue(symbol, includeTypeOnlyMembers) {
             return !!(symbol.flags & 111551 /* SymbolFlags.Value */ ||
-                symbol.flags & 2097152 /* SymbolFlags.Alias */ && resolveAlias(symbol).flags & 111551 /* SymbolFlags.Value */ && (includeTypeOnlyMembers || !getTypeOnlyAliasDeclaration(symbol)));
+                symbol.flags & 2097152 /* SymbolFlags.Alias */ && getAllSymbolFlags(symbol) & 111551 /* SymbolFlags.Value */ && (includeTypeOnlyMembers || !getTypeOnlyAliasDeclaration(symbol)));
         }
         function findConstructorDeclaration(node) {
             var members = node.members;
@@ -53047,8 +53105,10 @@ var ts;
                     return true;
                 }
                 // Qualify if the symbol from symbol table has same meaning as expected
-                symbolFromSymbolTable = (symbolFromSymbolTable.flags & 2097152 /* SymbolFlags.Alias */ && !ts.getDeclarationOfKind(symbolFromSymbolTable, 278 /* SyntaxKind.ExportSpecifier */)) ? resolveAlias(symbolFromSymbolTable) : symbolFromSymbolTable;
-                if (symbolFromSymbolTable.flags & meaning) {
+                var shouldResolveAlias = (symbolFromSymbolTable.flags & 2097152 /* SymbolFlags.Alias */ && !ts.getDeclarationOfKind(symbolFromSymbolTable, 278 /* SyntaxKind.ExportSpecifier */));
+                symbolFromSymbolTable = shouldResolveAlias ? resolveAlias(symbolFromSymbolTable) : symbolFromSymbolTable;
+                var flags = shouldResolveAlias ? getAllSymbolFlags(symbolFromSymbolTable) : symbolFromSymbolTable.flags;
+                if (flags & meaning) {
                     qualify = true;
                     return true;
                 }
@@ -55705,7 +55765,7 @@ var ts;
                     return !symbol.exports ? [] : ts.filter(ts.arrayFrom(symbol.exports.values()), isNamespaceMember);
                 }
                 function isTypeOnlyNamespace(symbol) {
-                    return ts.every(getNamespaceMembersForSerialization(symbol), function (m) { return !(resolveSymbol(m).flags & 111551 /* SymbolFlags.Value */); });
+                    return ts.every(getNamespaceMembersForSerialization(symbol), function (m) { return !(getAllSymbolFlags(resolveSymbol(m)) & 111551 /* SymbolFlags.Value */); });
                 }
                 function serializeModule(symbol, symbolName, modifierFlags) {
                     var members = getNamespaceMembersForSerialization(symbol);
@@ -57925,7 +57985,7 @@ var ts;
                 links.type = (exportSymbol === null || exportSymbol === void 0 ? void 0 : exportSymbol.declarations) && isDuplicatedCommonJSExport(exportSymbol.declarations) && symbol.declarations.length ? getFlowTypeFromCommonJSExport(exportSymbol)
                     : isDuplicatedCommonJSExport(symbol.declarations) ? autoType
                         : declaredType ? declaredType
-                            : targetSymbol.flags & 111551 /* SymbolFlags.Value */ ? getTypeOfSymbol(targetSymbol)
+                            : getAllSymbolFlags(targetSymbol) & 111551 /* SymbolFlags.Value */ ? getTypeOfSymbol(targetSymbol)
                                 : errorType;
             }
             return links.type;
@@ -60278,7 +60338,7 @@ var ts;
             var indexTypes;
             var isUnion = containingType.flags & 1048576 /* TypeFlags.Union */;
             // Flags we want to propagate to the result if they exist in all source symbols
-            var optionalFlag = isUnion ? 0 /* SymbolFlags.None */ : 16777216 /* SymbolFlags.Optional */;
+            var optionalFlag;
             var syntheticFlag = 4 /* CheckFlags.SyntheticMethod */;
             var checkFlags = isUnion ? 0 : 8 /* CheckFlags.Readonly */;
             var mergedInstantiations = false;
@@ -60289,11 +60349,14 @@ var ts;
                     var prop = getPropertyOfType(type, name, skipObjectFunctionPropertyAugment);
                     var modifiers = prop ? ts.getDeclarationModifierFlagsFromSymbol(prop) : 0;
                     if (prop) {
-                        if (isUnion) {
-                            optionalFlag |= (prop.flags & 16777216 /* SymbolFlags.Optional */);
-                        }
-                        else {
-                            optionalFlag &= prop.flags;
+                        if (prop.flags & 106500 /* SymbolFlags.ClassMember */) {
+                            optionalFlag !== null && optionalFlag !== void 0 ? optionalFlag : (optionalFlag = isUnion ? 0 /* SymbolFlags.None */ : 16777216 /* SymbolFlags.Optional */);
+                            if (isUnion) {
+                                optionalFlag |= (prop.flags & 16777216 /* SymbolFlags.Optional */);
+                            }
+                            else {
+                                optionalFlag &= prop.flags;
+                            }
                         }
                         if (!singleProp) {
                             singleProp = prop;
@@ -60412,7 +60475,7 @@ var ts;
                 propTypes.push(type);
             }
             ts.addRange(propTypes, indexTypes);
-            var result = createSymbol(4 /* SymbolFlags.Property */ | optionalFlag, name, syntheticFlag | checkFlags);
+            var result = createSymbol(4 /* SymbolFlags.Property */ | (optionalFlag !== null && optionalFlag !== void 0 ? optionalFlag : 0), name, syntheticFlag | checkFlags);
             result.containingType = containingType;
             if (!hasNonUniformValueDeclaration && firstValueDeclaration) {
                 result.valueDeclaration = firstValueDeclaration;
@@ -67679,7 +67742,7 @@ var ts;
                     return 0 /* Ternary.False */;
                 }
                 // When checking for comparability, be more lenient with optional properties.
-                if (!skipOptional && sourceProp.flags & 16777216 /* SymbolFlags.Optional */ && !(targetProp.flags & 16777216 /* SymbolFlags.Optional */)) {
+                if (!skipOptional && sourceProp.flags & 16777216 /* SymbolFlags.Optional */ && targetProp.flags & 106500 /* SymbolFlags.ClassMember */ && !(targetProp.flags & 16777216 /* SymbolFlags.Optional */)) {
                     // TypeScript 1.0 spec (April 2014): 3.8.3
                     // S is a subtype of a type T, and T is a supertype of S if ...
                     // S' and T are object types and, for each member M in T..
@@ -72951,9 +73014,9 @@ var ts;
             });
         }
         function markAliasReferenced(symbol, location) {
-            if (isNonLocalAlias(symbol, /*excludes*/ 111551 /* SymbolFlags.Value */) && !isInTypeQuery(location) && !getTypeOnlyAliasDeclaration(symbol)) {
+            if (isNonLocalAlias(symbol, /*excludes*/ 111551 /* SymbolFlags.Value */) && !isInTypeQuery(location) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* SymbolFlags.Value */)) {
                 var target = resolveAlias(symbol);
-                if (target.flags & 111551 /* SymbolFlags.Value */) {
+                if (getAllSymbolFlags(target) & 111551 /* SymbolFlags.Value */) {
                     // An alias resolving to a const enum cannot be elided if (1) 'isolatedModules' is enabled
                     // (because the const enum value will not be inlined), or if (2) the alias is an export
                     // of a const enum declaration that will be preserved.
@@ -78845,7 +78908,7 @@ var ts;
                     if (symbol && symbol.flags & 2097152 /* SymbolFlags.Alias */) {
                         symbol = resolveAlias(symbol);
                     }
-                    return !!(symbol && (symbol.flags & 384 /* SymbolFlags.Enum */) && getEnumKind(symbol) === 1 /* EnumKind.Literal */);
+                    return !!(symbol && (getAllSymbolFlags(symbol) & 384 /* SymbolFlags.Enum */) && getEnumKind(symbol) === 1 /* EnumKind.Literal */);
             }
             return false;
         }
@@ -85020,7 +85083,16 @@ var ts;
             var message = allowAsyncIterables
                 ? ts.Diagnostics.Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator
                 : ts.Diagnostics.Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator;
-            return errorAndMaybeSuggestAwait(errorNode, !!getAwaitedTypeOfPromise(type), message, typeToString(type));
+            var suggestAwait = 
+            // for (const x of Promise<...>) or [...Promise<...>]
+            !!getAwaitedTypeOfPromise(type)
+                // for (const x of AsyncIterable<...>)
+                || (!allowAsyncIterables &&
+                    ts.isForOfStatement(errorNode.parent) &&
+                    errorNode.parent.expression === errorNode &&
+                    getGlobalAsyncIterableType(/** reportErrors */ false) !== emptyGenericType &&
+                    isTypeAssignableTo(type, getGlobalAsyncIterableType(/** reportErrors */ false)));
+            return errorAndMaybeSuggestAwait(errorNode, suggestAwait, message, typeToString(type));
         }
         /**
          * Gets the *yield*, *return*, and *next* types from an `Iterator`-like or `AsyncIterator`-like type.
@@ -86871,10 +86943,11 @@ var ts;
                     }
                     return;
                 }
+                var targetFlags = getAllSymbolFlags(target);
                 var excludedMeanings = (symbol.flags & (111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */) ? 111551 /* SymbolFlags.Value */ : 0) |
                     (symbol.flags & 788968 /* SymbolFlags.Type */ ? 788968 /* SymbolFlags.Type */ : 0) |
                     (symbol.flags & 1920 /* SymbolFlags.Namespace */ ? 1920 /* SymbolFlags.Namespace */ : 0);
-                if (target.flags & excludedMeanings) {
+                if (targetFlags & excludedMeanings) {
                     var message = node.kind === 278 /* SyntaxKind.ExportSpecifier */ ?
                         ts.Diagnostics.Export_declaration_conflicts_with_exported_declaration_of_0 :
                         ts.Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0;
@@ -86884,7 +86957,7 @@ var ts;
                     && !ts.isTypeOnlyImportOrExportDeclaration(node)
                     && !(node.flags & 16777216 /* NodeFlags.Ambient */)) {
                     var typeOnlyAlias = getTypeOnlyAliasDeclaration(symbol);
-                    var isType = !(target.flags & 111551 /* SymbolFlags.Value */);
+                    var isType = !(targetFlags & 111551 /* SymbolFlags.Value */);
                     if (isType || typeOnlyAlias) {
                         switch (node.kind) {
                             case 270 /* SyntaxKind.ImportClause */:
@@ -87044,14 +87117,15 @@ var ts;
                 if (node.moduleReference.kind !== 280 /* SyntaxKind.ExternalModuleReference */) {
                     var target = resolveAlias(getSymbolOfNode(node));
                     if (target !== unknownSymbol) {
-                        if (target.flags & 111551 /* SymbolFlags.Value */) {
+                        var targetFlags = getAllSymbolFlags(target);
+                        if (targetFlags & 111551 /* SymbolFlags.Value */) {
                             // Target is a value symbol, check that it is not hidden by a local declaration with the same name
                             var moduleName = ts.getFirstIdentifier(node.moduleReference);
                             if (!(resolveEntityName(moduleName, 111551 /* SymbolFlags.Value */ | 1920 /* SymbolFlags.Namespace */).flags & 1920 /* SymbolFlags.Namespace */)) {
                                 error(moduleName, ts.Diagnostics.Module_0_is_hidden_by_a_local_declaration_with_the_same_name, ts.declarationNameToString(moduleName));
                             }
                         }
-                        if (target.flags & 788968 /* SymbolFlags.Type */) {
+                        if (targetFlags & 788968 /* SymbolFlags.Type */) {
                             checkTypeNameIsReserved(node.name, ts.Diagnostics.Import_name_cannot_be_0);
                         }
                     }
@@ -87190,7 +87264,7 @@ var ts;
                         markExportAsReferenced(node);
                     }
                     var target = symbol && (symbol.flags & 2097152 /* SymbolFlags.Alias */ ? resolveAlias(symbol) : symbol);
-                    if (!target || target === unknownSymbol || target.flags & 111551 /* SymbolFlags.Value */) {
+                    if (!target || getAllSymbolFlags(target) & 111551 /* SymbolFlags.Value */) {
                         checkExpressionCached(node.propertyName || node.name);
                     }
                 }
@@ -87237,7 +87311,7 @@ var ts;
                     markAliasReferenced(sym, id);
                     // If not a value, we're interpreting the identifier as a type export, along the lines of (`export { Id as default }`)
                     var target = sym.flags & 2097152 /* SymbolFlags.Alias */ ? resolveAlias(sym) : sym;
-                    if (target === unknownSymbol || target.flags & 111551 /* SymbolFlags.Value */) {
+                    if (getAllSymbolFlags(target) & 111551 /* SymbolFlags.Value */) {
                         // However if it is a value, we need to check it's being used correctly
                         checkExpressionCached(node.expression);
                     }
@@ -88559,7 +88633,7 @@ var ts;
             return symbolLinks.exportsSomeValue;
             function isValue(s) {
                 s = resolveSymbol(s);
-                return s && !!(s.flags & 111551 /* SymbolFlags.Value */);
+                return s && !!(getAllSymbolFlags(s) & 111551 /* SymbolFlags.Value */);
             }
         }
         function isNameOfModuleOrEnumDeclaration(node) {
@@ -88612,7 +88686,7 @@ var ts;
                 var symbol = getReferencedValueOrAliasSymbol(node);
                 // We should only get the declaration of an alias if there isn't a local value
                 // declaration for the symbol
-                if (isNonLocalAlias(symbol, /*excludes*/ 111551 /* SymbolFlags.Value */) && !getTypeOnlyAliasDeclaration(symbol)) {
+                if (isNonLocalAlias(symbol, /*excludes*/ 111551 /* SymbolFlags.Value */) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* SymbolFlags.Value */)) {
                     return getDeclarationOfAliasSymbol(symbol);
                 }
             }
@@ -88700,7 +88774,7 @@ var ts;
                 case 273 /* SyntaxKind.ImportSpecifier */:
                 case 278 /* SyntaxKind.ExportSpecifier */:
                     var symbol = getSymbolOfNode(node);
-                    return !!symbol && isAliasResolvedToValue(symbol) && !getTypeOnlyAliasDeclaration(symbol);
+                    return !!symbol && isAliasResolvedToValue(symbol) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* SymbolFlags.Value */);
                 case 275 /* SyntaxKind.ExportDeclaration */:
                     var exportClause = node.exportClause;
                     return !!exportClause && (ts.isNamespaceExport(exportClause) ||
@@ -88722,6 +88796,7 @@ var ts;
             return isValue && node.moduleReference && !ts.nodeIsMissing(node.moduleReference);
         }
         function isAliasResolvedToValue(symbol) {
+            var _a;
             if (!symbol) {
                 return false;
             }
@@ -88731,7 +88806,7 @@ var ts;
             }
             // const enums and modules that contain only const enums are not considered values from the emit perspective
             // unless 'preserveConstEnums' option is set to true
-            return !!(target.flags & 111551 /* SymbolFlags.Value */) &&
+            return !!(((_a = getAllSymbolFlags(target)) !== null && _a !== void 0 ? _a : -1) & 111551 /* SymbolFlags.Value */) &&
                 (ts.shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target));
         }
         function isConstEnumOrConstEnumOnlyModule(s) {
@@ -88746,7 +88821,7 @@ var ts;
                 }
                 var target = getSymbolLinks(symbol).aliasTarget; // TODO: GH#18217
                 if (target && ts.getEffectiveModifierFlags(node) & 1 /* ModifierFlags.Export */ &&
-                    target.flags & 111551 /* SymbolFlags.Value */ &&
+                    getAllSymbolFlags(target) & 111551 /* SymbolFlags.Value */ &&
                     (ts.shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target))) {
                     // An `export import ... =` of a value symbol is always considered referenced
                     return true;
@@ -129202,6 +129277,12 @@ var ts;
         SemanticClassificationFormat["Original"] = "original";
         SemanticClassificationFormat["TwentyTwenty"] = "2020";
     })(SemanticClassificationFormat = ts.SemanticClassificationFormat || (ts.SemanticClassificationFormat = {}));
+    var OrganizeImportsMode;
+    (function (OrganizeImportsMode) {
+        OrganizeImportsMode["All"] = "All";
+        OrganizeImportsMode["SortAndCombine"] = "SortAndCombine";
+        OrganizeImportsMode["RemoveUnused"] = "RemoveUnused";
+    })(OrganizeImportsMode = ts.OrganizeImportsMode || (ts.OrganizeImportsMode = {}));
     var CompletionTriggerKind;
     (function (CompletionTriggerKind) {
         /** Completion was triggered by typing an identifier, manual invocation (e.g Ctrl+Space) or via API. */
@@ -144957,23 +145038,39 @@ var ts;
          *   2) Coalescing imports from the same module
          *   3) Sorting imports
          */
-        function organizeImports(sourceFile, formatContext, host, program, preferences, skipDestructiveCodeActions) {
+        function organizeImports(sourceFile, formatContext, host, program, preferences, mode) {
             var changeTracker = ts.textChanges.ChangeTracker.fromContext({ host: host, formatContext: formatContext, preferences: preferences });
-            var coalesceAndOrganizeImports = function (importGroup) { return ts.stableSort(coalesceImports(removeUnusedImports(importGroup, sourceFile, program, skipDestructiveCodeActions)), function (s1, s2) { return compareImportsOrRequireStatements(s1, s2); }); };
+            var shouldSort = mode === "SortAndCombine" /* OrganizeImportsMode.SortAndCombine */ || mode === "All" /* OrganizeImportsMode.All */;
+            var shouldCombine = shouldSort; // These are currently inseparable, but I draw a distinction for clarity and in case we add modes in the future.
+            var shouldRemove = mode === "RemoveUnused" /* OrganizeImportsMode.RemoveUnused */ || mode === "All" /* OrganizeImportsMode.All */;
+            var maybeRemove = shouldRemove ? removeUnusedImports : ts.identity;
+            var maybeCoalesce = shouldCombine ? coalesceImports : ts.identity;
+            var processImportsOfSameModuleSpecifier = function (importGroup) {
+                var processedDeclarations = maybeCoalesce(maybeRemove(importGroup, sourceFile, program));
+                return shouldSort
+                    ? ts.stableSort(processedDeclarations, function (s1, s2) { return compareImportsOrRequireStatements(s1, s2); })
+                    : processedDeclarations;
+            };
             // All of the old ImportDeclarations in the file, in syntactic order.
             var topLevelImportGroupDecls = groupImportsByNewlineContiguous(sourceFile, sourceFile.statements.filter(ts.isImportDeclaration));
-            topLevelImportGroupDecls.forEach(function (importGroupDecl) { return organizeImportsWorker(importGroupDecl, coalesceAndOrganizeImports); });
-            // All of the old ExportDeclarations in the file, in syntactic order.
-            var topLevelExportDecls = sourceFile.statements.filter(ts.isExportDeclaration);
-            organizeImportsWorker(topLevelExportDecls, coalesceExports);
+            topLevelImportGroupDecls.forEach(function (importGroupDecl) { return organizeImportsWorker(importGroupDecl, processImportsOfSameModuleSpecifier); });
+            // Exports are always used
+            if (mode !== "RemoveUnused" /* OrganizeImportsMode.RemoveUnused */) {
+                // All of the old ExportDeclarations in the file, in syntactic order.
+                var topLevelExportDecls = sourceFile.statements.filter(ts.isExportDeclaration);
+                organizeImportsWorker(topLevelExportDecls, coalesceExports);
+            }
             for (var _i = 0, _a = sourceFile.statements.filter(ts.isAmbientModule); _i < _a.length; _i++) {
                 var ambientModule = _a[_i];
                 if (!ambientModule.body)
                     continue;
                 var ambientModuleImportGroupDecls = groupImportsByNewlineContiguous(sourceFile, ambientModule.body.statements.filter(ts.isImportDeclaration));
-                ambientModuleImportGroupDecls.forEach(function (importGroupDecl) { return organizeImportsWorker(importGroupDecl, coalesceAndOrganizeImports); });
-                var ambientModuleExportDecls = ambientModule.body.statements.filter(ts.isExportDeclaration);
-                organizeImportsWorker(ambientModuleExportDecls, coalesceExports);
+                ambientModuleImportGroupDecls.forEach(function (importGroupDecl) { return organizeImportsWorker(importGroupDecl, processImportsOfSameModuleSpecifier); });
+                // Exports are always used
+                if (mode !== "RemoveUnused" /* OrganizeImportsMode.RemoveUnused */) {
+                    var ambientModuleExportDecls = ambientModule.body.statements.filter(ts.isExportDeclaration);
+                    organizeImportsWorker(ambientModuleExportDecls, coalesceExports);
+                }
             }
             return changeTracker.getChanges();
             function organizeImportsWorker(oldImportDecls, coalesce) {
@@ -144986,8 +145083,12 @@ var ts;
                 // Consider: we could do a more careful check that this trivia is actually a header,
                 // but the consequences of being wrong are very minor.
                 ts.suppressLeadingTrivia(oldImportDecls[0]);
-                var oldImportGroups = ts.group(oldImportDecls, function (importDecl) { return getExternalModuleName(importDecl.moduleSpecifier); });
-                var sortedImportGroups = ts.stableSort(oldImportGroups, function (group1, group2) { return compareModuleSpecifiers(group1[0].moduleSpecifier, group2[0].moduleSpecifier); });
+                var oldImportGroups = shouldCombine
+                    ? ts.group(oldImportDecls, function (importDecl) { return getExternalModuleName(importDecl.moduleSpecifier); })
+                    : [oldImportDecls];
+                var sortedImportGroups = shouldSort
+                    ? ts.stableSort(oldImportGroups, function (group1, group2) { return compareModuleSpecifiers(group1[0].moduleSpecifier, group2[0].moduleSpecifier); })
+                    : oldImportGroups;
                 var newImportDecls = ts.flatMap(sortedImportGroups, function (importGroup) {
                     return getExternalModuleName(importGroup[0].moduleSpecifier)
                         ? coalesce(importGroup)
@@ -145051,11 +145152,7 @@ var ts;
             }
             return false;
         }
-        function removeUnusedImports(oldImports, sourceFile, program, skipDestructiveCodeActions) {
-            // As a precaution, consider unused import detection to be destructive (GH #43051)
-            if (skipDestructiveCodeActions) {
-                return oldImports;
-            }
+        function removeUnusedImports(oldImports, sourceFile, program) {
             var typeChecker = program.getTypeChecker();
             var compilerOptions = program.getCompilerOptions();
             var jsxNamespace = typeChecker.getJsxNamespace(sourceFile);
@@ -154088,6 +154185,15 @@ var ts;
             });
         }
         function makeChange(changeTracker, errorCode, sourceFile, checker, insertionSite, fixedDeclarations) {
+            if (ts.isForOfStatement(insertionSite.parent) && !insertionSite.parent.awaitModifier) {
+                var exprType = checker.getTypeAtLocation(insertionSite);
+                var asyncIter = checker.getAsyncIterableType();
+                if (asyncIter && checker.isTypeAssignableTo(exprType, asyncIter)) {
+                    var forOf = insertionSite.parent;
+                    changeTracker.replaceNode(sourceFile, forOf, ts.factory.updateForOfStatement(forOf, ts.factory.createToken(133 /* SyntaxKind.AwaitKeyword */), forOf.initializer, forOf.expression, forOf.statement));
+                    return;
+                }
+            }
             if (ts.isBinaryExpression(insertionSite)) {
                 for (var _i = 0, _a = [insertionSite.left, insertionSite.right]; _i < _a.length; _i++) {
                     var side = _a[_i];
@@ -169443,12 +169549,14 @@ var ts;
             return ts.codefix.getAllFixes({ fixId: fixId, sourceFile: sourceFile, program: program, host: host, cancellationToken: cancellationToken, formatContext: formatContext, preferences: preferences });
         }
         function organizeImports(args, formatOptions, preferences) {
+            var _a;
             if (preferences === void 0) { preferences = ts.emptyOptions; }
             synchronizeHostData();
             ts.Debug.assert(args.type === "file");
             var sourceFile = getValidSourceFile(args.fileName);
             var formatContext = ts.formatting.getFormatContext(formatOptions, host);
-            return ts.OrganizeImports.organizeImports(sourceFile, formatContext, host, program, preferences, args.skipDestructiveCodeActions);
+            var mode = (_a = args.mode) !== null && _a !== void 0 ? _a : (args.skipDestructiveCodeActions ? "SortAndCombine" /* OrganizeImportsMode.SortAndCombine */ : "All" /* OrganizeImportsMode.All */);
+            return ts.OrganizeImports.organizeImports(sourceFile, formatContext, host, program, preferences, mode);
         }
         function getEditsForFileRename(oldFilePath, newFilePath, formatOptions, preferences) {
             if (preferences === void 0) { preferences = ts.emptyOptions; }
@@ -172028,6 +172136,12 @@ var ts;
                 CommandTypes["ProvideInlayHints"] = "provideInlayHints";
                 // NOTE: If updating this, be sure to also update `allCommandNames` in `testRunner/unittests/tsserver/session.ts`.
             })(CommandTypes = protocol.CommandTypes || (protocol.CommandTypes = {}));
+            var OrganizeImportsMode;
+            (function (OrganizeImportsMode) {
+                OrganizeImportsMode["All"] = "All";
+                OrganizeImportsMode["SortAndCombine"] = "SortAndCombine";
+                OrganizeImportsMode["RemoveUnused"] = "RemoveUnused";
+            })(OrganizeImportsMode = protocol.OrganizeImportsMode || (protocol.OrganizeImportsMode = {}));
             var WatchFileKind;
             (function (WatchFileKind) {
                 WatchFileKind["FixedPollingInterval"] = "FixedPollingInterval";
@@ -181191,11 +181305,12 @@ var ts;
                 }
             };
             Session.prototype.organizeImports = function (args, simplifiedResult) {
+                var _a;
                 ts.Debug.assert(args.scope.type === "file");
-                var _a = this.getFileAndProject(args.scope.args), file = _a.file, project = _a.project;
+                var _b = this.getFileAndProject(args.scope.args), file = _b.file, project = _b.project;
                 var changes = project.getLanguageService().organizeImports({
                     fileName: file,
-                    skipDestructiveCodeActions: args.skipDestructiveCodeActions,
+                    mode: (_a = args.mode) !== null && _a !== void 0 ? _a : (args.skipDestructiveCodeActions ? "SortAndCombine" /* OrganizeImportsMode.SortAndCombine */ : undefined),
                     type: "file",
                 }, this.getFormatOptions(file), this.getPreferences(file));
                 if (simplifiedResult) {

package/lib/typescript.d.ts

@@ -6032,8 +6032,15 @@ declare namespace ts {
         type: "file";
         fileName: string;
     }
+    enum OrganizeImportsMode {
+        All = "All",
+        SortAndCombine = "SortAndCombine",
+        RemoveUnused = "RemoveUnused"
+    }
     interface OrganizeImportsArgs extends CombinedCodeFixScope {
+        /** @deprecated Use `mode` instead */
         skipDestructiveCodeActions?: boolean;
+        mode?: OrganizeImportsMode;
     }
     type CompletionsTriggerCharacter = "." | '"' | "'" | "`" | "/" | "@" | "<" | "#" | " ";
     enum CompletionTriggerKind {