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

package/lib/typingsInstaller.js

@@ -89,7 +89,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) {
@@ -49478,6 +49478,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,
@@ -50315,9 +50321,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;
                         }
                     }
@@ -50950,8 +50956,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;
@@ -51038,7 +51044,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
@@ -51201,7 +51207,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));
@@ -51212,7 +51218,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);
@@ -51260,16 +51267,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;
@@ -51859,6 +51866,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
@@ -51904,19 +51957,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);
                 }
@@ -51936,8 +51995,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);
                     }
@@ -52759,7 +52817,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;
@@ -53028,8 +53086,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;
                 }
@@ -55686,7 +55746,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);
@@ -57906,7 +57966,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;
@@ -60259,7 +60319,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;
@@ -60270,11 +60330,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;
@@ -60393,7 +60456,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;
@@ -67660,7 +67723,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..
@@ -72932,9 +72995,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.
@@ -78826,7 +78889,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;
         }
@@ -85001,7 +85064,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.
@@ -86852,10 +86924,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;
@@ -86865,7 +86938,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 */:
@@ -87025,14 +87098,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);
                         }
                     }
@@ -87171,7 +87245,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);
                     }
                 }
@@ -87218,7 +87292,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);
                     }
@@ -88540,7 +88614,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) {
@@ -88593,7 +88667,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);
                 }
             }
@@ -88681,7 +88755,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) ||
@@ -88703,6 +88777,7 @@ var ts;
             return isValue && node.moduleReference && !ts.nodeIsMissing(node.moduleReference);
         }
         function isAliasResolvedToValue(symbol) {
+            var _a;
             if (!symbol) {
                 return false;
             }
@@ -88712,7 +88787,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) {
@@ -88727,7 +88802,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;

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "4.9.0-dev.20220929",
+    "version": "4.9.0-dev.20220930",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [
@@ -89,7 +89,7 @@
         "ms": "^2.1.3",
         "node-fetch": "^2.6.7",
         "source-map-support": "latest",
-        "typescript": "^4.8.3",
+        "typescript": "^4.8.4",
         "vinyl": "latest",
         "which": "^2.0.2",
         "xml2js": "^0.4.23"