tsc-ts 0.0.9 → 0.1.0

package/dist/api/compiler/checker-narrowing.js

@@ -6,12 +6,12 @@ import { cachedTypeKey, cachedTypePairKey, } from './checker-types.js';
 import { getSymbolId } from './symbol.js';
 import { getNodeId } from './ast.js';
 import { getAdjustedTypeWithFacts, getNonNullableType, getTypeFacts, getTypeWithFacts, hasTypeFacts, } from './checker-flow.js';
-import { everyType, filterType, getBaseTypeOfLiteralType, getFreshTypeOfLiteralType, getIntersectionType, getRegularTypeOfLiteralType, getUnionType, getUnionTypeEx, getWidenedLiteralType, isEmptyAnonymousObjectType, isFreshLiteralType, isLiteralType, isPatternLiteralType, isUnitType, mapType, removeType, someType, typesOf, containsMissingType, getNumberLiteralType, createArrayType, isTupleType, newObjectType, } from './checker-type-factory.js';
+import { everyType, filterType, getBaseTypeOfLiteralType, getFreshTypeOfLiteralType, getIntersectionType, getRegularTypeOfLiteralType, getUnionType, getUnionTypeEx, getWidenedLiteralType, isEmptyAnonymousObjectType, isFreshLiteralType, isLiteralType, isPatternLiteralType, isUnitType, mapType, removeType, someType, typesOf, containsMissingType, getNumberLiteralType, createArrayType, isTupleType, newObjectType, unionContainsTypeOrPrimitive, } from './checker-type-factory.js';
 import { areTypesComparable, isDiscriminantProperty, isTypeAssignableTo, isTypeDerivedFrom, isTypeRelatedTo, isTypeStrictSubtypeOf, isTypeSubsetOf, isTypeSubtypeOf, } from './relations.js';
 import { checkExpression, checkExpressionCached, checkExpressionEx, checkNonNullExpression, checkNonNullType, getNarrowableTypeForReference, someTypeIsGenericWithUnionConstraint, getResolvedSymbol, getTypeOfExpression, isThisInTypeQuery, isTupleLikeType, } from './checker-expressions.js';
 import { isBlockScopedNameDeclaredBeforeUse } from './checker-declaration-order.js';
 import { getContextualSignature, getInferenceContext, isContextSensitiveFunctionOrObjectLiteralMethod, } from './checker-contextual.js';
-import { instantiateType } from './instantiation.js';
+import { instantiateType, isNodeDescendantOf } from './instantiation.js';
 import { checkIteratedTypeOrElementType } from './checker-iteration.js';
 import { checkSuperExpression } from './checker-super.js';
 import { getSymbolNameForPrivateIdentifier } from './binder.js';
@@ -20,7 +20,7 @@ import { getRegularTypeOfObjectLiteral } from './checker-literals.js';
 import { checkRightHandSideOfForOf } from './checker-statements.js';
 import { getApparentType, getApplicableIndexInfoForName, getBaseConstraintOfType, getPropertiesOfType, getPropertyOfType, getReducedApparentType, getSignaturesOfType, getTypeOfPropertyOfType, mapToBaseConstraintOrType, } from './checker-members.js';
 import { getAssignmentTarget, isAssignmentTarget, isPushOrUnshiftIdentifier, getCombinedModifierFlags, hasStaticModifier, getCombinedNodeFlags, getImmediatelyInvokedFunctionExpression, getRootDeclaration, getThisContainer, isAssignmentExpression, isClassLike, isEntityNameExpression, isObjectLiteralMethod, isExpressionOfOptionalChainRoot, isGlobalSourceFile, isLogicalOrCoalescingAssignmentOperator, isOptionalChain, isStatic, skipParentheses, getRangeOfTokenAtPosition, getSourceFileOfNode, } from './binder-utilities.js';
-import { getDeclaredTypeOfSymbol, isConstructorType } from './checker-declared-types.js';
+import { getDeclaredTypeOfSymbol, getParentOfSymbol, isConstructorType } from './checker-declared-types.js';
 import { getErasedSignature, getReturnTypeFromAnnotation, getReturnTypeOfSignature, getSignatureFromDeclaration, getTypePredicateOfSignature, } from './checker-signatures.js';
 import { getExportSymbolOfValueSymbolIfExported, getSymbolOfDeclaration, resolveEntityName, resolveSymbol, getGlobalTypeAliasSymbol, } from './checker-symbols.js';
 import { getOptionalType, getTypeOfSymbol, isReadonlySymbol } from './checker-symbol-types.js';
@@ -139,8 +139,8 @@ function isDottedReference(node) {
                 return !isThisInTypeQuery(n);
             case 109 /* SyntaxKind.ThisKeyword */:
                 return true;
-            case 212 /* SyntaxKind.PropertyAccessExpression */:
-            case 213 /* SyntaxKind.ElementAccessExpression */:
+            case 213 /* SyntaxKind.PropertyAccessExpression */:
+            case 214 /* SyntaxKind.ElementAccessExpression */:
                 n = getExpression(n);
                 break;
             default:
@@ -155,8 +155,8 @@ function isDottedReference(node) {
  */
 function hasKeyCharacterInName(c, node) {
     let n = node;
-    while (n.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || n.kind === 213 /* SyntaxKind.ElementAccessExpression */) {
-        if (n.kind === 213 /* SyntaxKind.ElementAccessExpression */) {
+    while (n.kind === 213 /* SyntaxKind.PropertyAccessExpression */ || n.kind === 214 /* SyntaxKind.ElementAccessExpression */) {
+        if (n.kind === 214 /* SyntaxKind.ElementAccessExpression */) {
             const name = getAccessedPropertyName(c, n);
             if (name !== undefined && /[.@#]/.test(name))
                 return true;
@@ -231,7 +231,7 @@ export function getFlowTypeOfReferenceAt(c, reference, declaredType, initialType
         : finalizeEvolvingArrayType(c, evolvedType);
     if (resultType === c.unreachableNeverType ||
         (reference.parent !== undefined &&
-            reference.parent.kind === 236 /* SyntaxKind.NonNullExpression */ &&
+            reference.parent.kind === 237 /* SyntaxKind.NonNullExpression */ &&
             (resultType.flags & 262144 /* TypeFlags.Never */) === 0 &&
             (getTypeWithFacts(c, resultType, 2097152 /* TypeFacts.NEUndefinedOrNull */).flags & 262144 /* TypeFlags.Never */) !== 0))
         return declaredType;
@@ -357,9 +357,9 @@ export function getTypeAtFlowNode(c, f, start) {
             const container = flow.node;
             if (container !== undefined &&
                 container !== f.flowContainer &&
-                f.reference.kind !== 212 /* SyntaxKind.PropertyAccessExpression */ &&
-                f.reference.kind !== 213 /* SyntaxKind.ElementAccessExpression */ &&
-                !(f.reference.kind === 109 /* SyntaxKind.ThisKeyword */ && container.kind !== 220 /* SyntaxKind.ArrowFunction */)) {
+                f.reference.kind !== 213 /* SyntaxKind.PropertyAccessExpression */ &&
+                f.reference.kind !== 214 /* SyntaxKind.ElementAccessExpression */ &&
+                !(f.reference.kind === 109 /* SyntaxKind.ThisKeyword */ && container.kind !== 221 /* SyntaxKind.ArrowFunction */)) {
                 const outer = getFlowNode(container);
                 if (outer !== undefined) {
                     flow = outer;
@@ -442,7 +442,7 @@ function getTypeAtFlowAssignment(c, f, flow) {
             return complete(f, c.unreachableNeverType);
         // The dotted name may be an expando property of a function expression; its flow continues
         // back past the function's declaration.
-        if (node.kind === 261 /* SyntaxKind.VariableDeclaration */) {
+        if (node.kind === 262 /* SyntaxKind.VariableDeclaration */) {
             const blockScope = getCombinedNodeFlags(node) & 7 /* NodeFlags.BlockScoped */;
             const initializer = getInitializer(node);
             if ((isInJSFile(node) ||
@@ -450,13 +450,13 @@ function getTypeAtFlowAssignment(c, f, flow) {
                 blockScope === 4 /* NodeFlags.Using */ ||
                 blockScope === 6 /* NodeFlags.AwaitUsing */) &&
                 initializer !== undefined &&
-                (initializer.kind === 219 /* SyntaxKind.FunctionExpression */ || initializer.kind === 220 /* SyntaxKind.ArrowFunction */))
+                (initializer.kind === 220 /* SyntaxKind.FunctionExpression */ || initializer.kind === 221 /* SyntaxKind.ArrowFunction */))
                 return getTypeAtFlowNode(c, f, flow.antecedent);
         }
         return complete(f, f.declaredType);
     }
     // `for (const _ in ref)` acts as a non-null check of `ref`.
-    if (node.kind === 261 /* SyntaxKind.VariableDeclaration */ && node.parent.parent.kind === 250 /* SyntaxKind.ForInStatement */) {
+    if (node.kind === 262 /* SyntaxKind.VariableDeclaration */ && node.parent.parent.kind === 251 /* SyntaxKind.ForInStatement */) {
         const statementExpression = getExpression(node.parent.parent);
         if (isMatchingReference(c, f.reference, statementExpression) ||
             optionalChainContainsReference(c, statementExpression, f.reference)) {
@@ -468,21 +468,21 @@ function getTypeAtFlowAssignment(c, f, flow) {
     return undefined;
 }
 function isEmptyArrayAssignment(node) {
-    if (node.kind === 261 /* SyntaxKind.VariableDeclaration */) {
+    if (node.kind === 262 /* SyntaxKind.VariableDeclaration */) {
         const initializer = getInitializer(node);
         return initializer !== undefined && isEmptyArrayLiteral(initializer);
     }
     const parent = node.parent;
-    return (node.kind !== 209 /* SyntaxKind.BindingElement */ &&
-        parent.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+    return (node.kind !== 210 /* SyntaxKind.BindingElement */ &&
+        parent.kind === 228 /* SyntaxKind.BinaryExpression */ &&
         isEmptyArrayLiteral(parent.right));
 }
 function isEmptyArrayLiteral(node) {
-    return node.kind === 210 /* SyntaxKind.ArrayLiteralExpression */ && getElements(node).nodes.length === 0;
+    return node.kind === 211 /* SyntaxKind.ArrayLiteralExpression */ && getElements(node).nodes.length === 0;
 }
 function getInitialOrAssignedType(c, f, flow) {
     const node = flow.node;
-    const t = node.kind === 261 /* SyntaxKind.VariableDeclaration */ || node.kind === 209 /* SyntaxKind.BindingElement */
+    const t = node.kind === 262 /* SyntaxKind.VariableDeclaration */ || node.kind === 210 /* SyntaxKind.BindingElement */
         ? getInitialType(c, node)
         : getAssignedType(c, node);
     // getNarrowableTypeForReference looks at the reference's position for these.
@@ -491,14 +491,14 @@ function getInitialOrAssignedType(c, f, flow) {
     return getNarrowableTypeForReference(c, t, f.reference);
 }
 function getInitialType(c, node) {
-    if (node.kind === 261 /* SyntaxKind.VariableDeclaration */) {
+    if (node.kind === 262 /* SyntaxKind.VariableDeclaration */) {
         const initializer = getInitializer(node);
         if (initializer !== undefined)
             return getTypeOfInitializer(c, initializer);
         const statement = node.parent.parent;
-        if (statement.kind === 250 /* SyntaxKind.ForInStatement */)
+        if (statement.kind === 251 /* SyntaxKind.ForInStatement */)
             return c.stringType;
-        if (statement.kind === 251 /* SyntaxKind.ForOfStatement */)
+        if (statement.kind === 252 /* SyntaxKind.ForOfStatement */)
             return checkRightHandSideOfForOf(c, statement);
         return c.errorType;
     }
@@ -512,7 +512,7 @@ function getInitialTypeOfBindingElement(c, node) {
     const pattern = node.parent;
     const parentType = getInitialType(c, pattern.parent);
     let t;
-    if (pattern.kind === 207 /* SyntaxKind.ObjectBindingPattern */)
+    if (pattern.kind === 208 /* SyntaxKind.ObjectBindingPattern */)
         t = getTypeOfDestructuredProperty(c, parentType, (node.propertyName ?? node.name));
     else if (node.dotDotDotToken === undefined)
         t = getTypeOfDestructuredArrayElement(c, parentType, getElements(pattern).nodes.indexOf(node));
@@ -523,37 +523,37 @@ function getInitialTypeOfBindingElement(c, node) {
 function getAssignedType(c, node) {
     const parent = node.parent;
     switch (parent.kind) {
-        case 250 /* SyntaxKind.ForInStatement */:
+        case 251 /* SyntaxKind.ForInStatement */:
             return c.stringType;
-        case 251 /* SyntaxKind.ForOfStatement */:
+        case 252 /* SyntaxKind.ForOfStatement */:
             return checkRightHandSideOfForOf(c, parent);
-        case 227 /* SyntaxKind.BinaryExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
             return getAssignedTypeOfBinaryExpression(c, parent);
-        case 221 /* SyntaxKind.DeleteExpression */:
+        case 222 /* SyntaxKind.DeleteExpression */:
             return c.undefinedType;
-        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
             return getTypeOfDestructuredArrayElement(c, getAssignedType(c, parent), getElements(parent).nodes.indexOf(node));
-        case 231 /* SyntaxKind.SpreadElement */:
+        case 232 /* SyntaxKind.SpreadElement */:
             return getTypeOfDestructuredSpreadExpression(c, getAssignedType(c, parent.parent));
-        case 303 /* SyntaxKind.PropertyAssignment */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
             return getAssignedTypeOfPropertyAssignment(c, parent);
-        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
             return getTypeWithDefault(c, getAssignedTypeOfPropertyAssignment(c, parent), parent.objectAssignmentInitializer);
     }
     return c.errorType;
 }
 function getAssignedTypeOfBinaryExpression(c, node) {
     const parent = node.parent;
-    const isDestructuringDefaultAssignment = (parent.kind === 210 /* SyntaxKind.ArrayLiteralExpression */ && isDestructuringAssignmentTarget(parent)) ||
-        (parent.kind === 303 /* SyntaxKind.PropertyAssignment */ && isDestructuringAssignmentTarget(parent.parent));
+    const isDestructuringDefaultAssignment = (parent.kind === 211 /* SyntaxKind.ArrayLiteralExpression */ && isDestructuringAssignmentTarget(parent)) ||
+        (parent.kind === 304 /* SyntaxKind.PropertyAssignment */ && isDestructuringAssignmentTarget(parent.parent));
     if (isDestructuringDefaultAssignment)
         return getTypeWithDefault(c, getAssignedType(c, node), node.right);
     return getTypeOfExpression(c, node.right);
 }
 function isDestructuringAssignmentTarget(parent) {
     const grandparent = parent.parent;
-    return ((grandparent.kind === 227 /* SyntaxKind.BinaryExpression */ && grandparent.left === parent) ||
-        (grandparent.kind === 251 /* SyntaxKind.ForOfStatement */ && grandparent.initializer === parent));
+    return ((grandparent.kind === 228 /* SyntaxKind.BinaryExpression */ && grandparent.left === parent) ||
+        (grandparent.kind === 252 /* SyntaxKind.ForOfStatement */ && grandparent.initializer === parent));
 }
 function getAssignedTypeOfPropertyAssignment(c, node) {
     return getTypeOfDestructuredProperty(c, getAssignedType(c, node.parent), getName(node));
@@ -659,7 +659,7 @@ function narrowTypeByAssertion(c, f, t, expr) {
     const node = skipParentheses(expr);
     if (node.kind === 96 /* SyntaxKind.FalseKeyword */)
         return c.unreachableNeverType;
-    if (node.kind === 227 /* SyntaxKind.BinaryExpression */) {
+    if (node.kind === 228 /* SyntaxKind.BinaryExpression */) {
         const binary = node;
         if (binary.operatorToken.kind === 55 /* SyntaxKind.AmpersandAmpersandToken */)
             return narrowTypeByAssertion(c, f, narrowTypeByAssertion(c, f, t, binary.left), binary.right);
@@ -678,12 +678,12 @@ export function getEffectsSignature(c, node) {
     if (signature === undefined) {
         // Assertion calls resolve their target with getTypeOfDottedName to avoid circularities.
         let funcType = undefined;
-        if (node.kind === 227 /* SyntaxKind.BinaryExpression */)
+        if (node.kind === 228 /* SyntaxKind.BinaryExpression */)
             funcType = getSymbolHasInstanceMethodOfObjectType(c, checkNonNullExpression(c, node.right));
         else {
             const callee = getExpression(node);
             // Assertions resolve their target without inference, to avoid circularities in flow analysis.
-            if (node.parent.kind === 245 /* SyntaxKind.ExpressionStatement */)
+            if (node.parent.kind === 246 /* SyntaxKind.ExpressionStatement */)
                 funcType = getTypeOfDottedName(c, callee);
             else if (callee.kind !== 107 /* SyntaxKind.SuperKeyword */)
                 funcType = isOptionalChain(node)
@@ -728,7 +728,7 @@ function getTypeOfDottedName(c, node) {
             return getExplicitThisType(c, node);
         case 107 /* SyntaxKind.SuperKeyword */:
             return checkSuperExpression(c, node);
-        case 212 /* SyntaxKind.PropertyAccessExpression */: {
+        case 213 /* SyntaxKind.PropertyAccessExpression */: {
             const t = getTypeOfDottedName(c, getExpression(node));
             if (t === undefined)
                 return undefined;
@@ -743,17 +743,27 @@ function getTypeOfDottedName(c, node) {
                 prop = getPropertyOfType(c, t, getText(name));
             return prop !== undefined ? getExplicitTypeOfSymbol(c, prop) : undefined;
         }
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
             return getTypeOfDottedName(c, getExpression(node));
     }
     return undefined;
 }
 function getExplicitTypeOfSymbol(c, original) {
     const symbol = resolveSymbol(c, original) ?? original;
+    // `for (const x of x.y)` asks for the explicit type of `x` while finding it.
+    const resolving = c.resolvingExplicitTypeOfSymbol;
+    if (resolving.has(symbol))
+        return undefined;
+    resolving.add(symbol);
+    const result = getExplicitTypeOfResolvedSymbol(c, symbol);
+    resolving.delete(symbol);
+    return result;
+}
+function getExplicitTypeOfResolvedSymbol(c, symbol) {
     if ((symbol.flags & (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */ | 32 /* SymbolFlags.Class */ | 512 /* SymbolFlags.ValueModule */)) !== 0)
         return getTypeOfSymbol(c, symbol);
     if ((symbol.flags & (3 /* SymbolFlags.Variable */ | 4 /* SymbolFlags.Property */)) !== 0) {
-        if ((symbol.checkFlags & 262144 /* CheckFlags.Mapped */) !== 0) {
+        if ((symbol.checkFlags & 2097152 /* CheckFlags.Mapped */) !== 0) {
             const origin = c.symbolSyntheticOrigins.get(getSymbolId(symbol));
             if (origin !== undefined && getExplicitTypeOfSymbol(c, origin) !== undefined)
                 return getTypeOfSymbol(c, symbol);
@@ -763,8 +773,8 @@ function getExplicitTypeOfSymbol(c, original) {
             if (isDeclarationWithExplicitTypeAnnotation(declaration))
                 return getTypeOfSymbol(c, symbol);
             // `for (const x of xs)` where `xs` has an explicit type.
-            if (declaration.kind === 261 /* SyntaxKind.VariableDeclaration */ &&
-                declaration.parent.parent.kind === 251 /* SyntaxKind.ForOfStatement */) {
+            if (declaration.kind === 262 /* SyntaxKind.VariableDeclaration */ &&
+                declaration.parent.parent.kind === 252 /* SyntaxKind.ForOfStatement */) {
                 const statement = declaration.parent.parent;
                 const expressionType = getTypeOfDottedName(c, statement.expression);
                 if (expressionType !== undefined)
@@ -776,12 +786,12 @@ function getExplicitTypeOfSymbol(c, original) {
 }
 function isDeclarationWithExplicitTypeAnnotation(node) {
     switch (node.kind) {
-        case 261 /* SyntaxKind.VariableDeclaration */:
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 172 /* SyntaxKind.PropertySignature */:
-        case 170 /* SyntaxKind.Parameter */:
+        case 262 /* SyntaxKind.VariableDeclaration */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 171 /* SyntaxKind.Parameter */:
             return getType(node) !== undefined;
-        case 227 /* SyntaxKind.BinaryExpression */: {
+        case 228 /* SyntaxKind.BinaryExpression */: {
             // An expando property assigned a function with a return type annotation.
             const right = node.right;
             return isFunctionLike(right) && getType(right) !== undefined;
@@ -982,22 +992,22 @@ function writeFlowCacheKey(c, node, declaredType, initialType, flowContainer) {
                 key += '@' + getNodeId(flowContainer);
             return key;
         }
-        case 236 /* SyntaxKind.NonNullExpression */:
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 237 /* SyntaxKind.NonNullExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
             return writeFlowCacheKey(c, getExpression(node), declaredType, initialType, flowContainer);
-        case 167 /* SyntaxKind.QualifiedName */: {
+        case 168 /* SyntaxKind.QualifiedName */: {
             const left = writeFlowCacheKey(c, node.left, declaredType, initialType, flowContainer);
-            return left === undefined ? undefined : left + '.' + node.right.text;
+            return left === undefined ? undefined : left + '.' + getText(node.right);
         }
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-        case 213 /* SyntaxKind.ElementAccessExpression */: {
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */: {
             const name = getAccessedPropertyName(c, node);
             if (name !== undefined) {
                 const left = writeFlowCacheKey(c, getExpression(node), declaredType, initialType, flowContainer);
                 return left === undefined ? undefined : left + '.' + name;
             }
             // `obj[key]` for a key that isn't reassigned.
-            if (node.kind !== 213 /* SyntaxKind.ElementAccessExpression */)
+            if (node.kind !== 214 /* SyntaxKind.ElementAccessExpression */)
                 return undefined;
             const argument = node.argumentExpression;
             if (argument.kind !== 79 /* SyntaxKind.Identifier */)
@@ -1009,12 +1019,12 @@ function writeFlowCacheKey(c, node, declaredType, initialType, flowContainer) {
             return left === undefined ? undefined : left + '.@' + getSymbolId(symbol);
         }
         // Pseudo-references of getNarrowedTypeOfSymbol.
-        case 207 /* SyntaxKind.ObjectBindingPattern */:
-        case 208 /* SyntaxKind.ArrayBindingPattern */:
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 208 /* SyntaxKind.ObjectBindingPattern */:
+        case 209 /* SyntaxKind.ArrayBindingPattern */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
             return '#' + getNodeId(node) + '#' + declaredType.id;
     }
     return undefined;
@@ -1025,7 +1035,7 @@ function narrowType(c, f, t, expr, assumeTrue) {
     const parent = expr.parent;
     if (isExpressionOfOptionalChainRoot(expr) ||
         (parent !== undefined &&
-            parent.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+            parent.kind === 228 /* SyntaxKind.BinaryExpression */ &&
             (parent.operatorToken.kind === 60 /* SyntaxKind.QuestionQuestionToken */ ||
                 parent.operatorToken.kind === 77 /* SyntaxKind.QuestionQuestionEqualsToken */) &&
             parent.left === expr))
@@ -1038,7 +1048,7 @@ function narrowType(c, f, t, expr, assumeTrue) {
                 if (isConstantVariable(c, symbol)) {
                     const declaration = symbol.valueDeclaration;
                     if (declaration !== undefined &&
-                        declaration.kind === 261 /* SyntaxKind.VariableDeclaration */ &&
+                        declaration.kind === 262 /* SyntaxKind.VariableDeclaration */ &&
                         getType(declaration) === undefined) {
                         const initializer = getInitializer(declaration);
                         // For an access, isConstantReference reads the property symbol resolved where the
@@ -1057,18 +1067,18 @@ function narrowType(c, f, t, expr, assumeTrue) {
             return narrowTypeByTruthiness(c, f, t, expr, assumeTrue);
         case 109 /* SyntaxKind.ThisKeyword */:
         case 107 /* SyntaxKind.SuperKeyword */:
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-        case 213 /* SyntaxKind.ElementAccessExpression */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */:
             return narrowTypeByTruthiness(c, f, t, expr, assumeTrue);
-        case 214 /* SyntaxKind.CallExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
             return narrowTypeByCallExpression(c, f, t, expr, assumeTrue);
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
-        case 236 /* SyntaxKind.NonNullExpression */:
-        case 239 /* SyntaxKind.SatisfiesExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
+        case 237 /* SyntaxKind.NonNullExpression */:
+        case 240 /* SyntaxKind.SatisfiesExpression */:
             return narrowType(c, f, t, getExpression(expr), assumeTrue);
-        case 227 /* SyntaxKind.BinaryExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
             return narrowTypeByBinaryExpression(c, f, t, expr, assumeTrue);
-        case 225 /* SyntaxKind.PrefixUnaryExpression */:
+        case 226 /* SyntaxKind.PrefixUnaryExpression */:
             if (expr.operator === 53 /* SyntaxKind.ExclamationToken */)
                 return narrowType(c, f, t, expr.operand, !assumeTrue);
             break;
@@ -1106,7 +1116,7 @@ function narrowTypeByCallExpression(c, f, t, call, assumeTrue) {
     // `obj.hasOwnProperty("p")` narrows an optional `obj.p` under exactOptionalPropertyTypes.
     if (containsMissingType(c, t) && isAccessExpression(f.reference)) {
         const callee = getExpression(call);
-        if (callee.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+        if (callee.kind === 213 /* SyntaxKind.PropertyAccessExpression */) {
             const name = callee.name;
             const args = getArguments(call).nodes;
             if (isMatchingReference(c, getExpression(f.reference), getReferenceCandidate(getExpression(callee))) &&
@@ -1153,7 +1163,7 @@ function getTypePredicateArgument(predicate, call) {
             : undefined;
     }
     const invoked = skipParentheses(getExpression(call));
-    return invoked.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || invoked.kind === 213 /* SyntaxKind.ElementAccessExpression */
+    return invoked.kind === 213 /* SyntaxKind.PropertyAccessExpression */ || invoked.kind === 214 /* SyntaxKind.ElementAccessExpression */
         ? skipParentheses(getExpression(invoked))
         : undefined;
 }
@@ -1171,9 +1181,9 @@ function narrowTypeByBinaryExpression(c, f, t, expr, assumeTrue) {
         case 37 /* SyntaxKind.ExclamationEqualsEqualsToken */: {
             const left = getReferenceCandidate(expr.left);
             const right = getReferenceCandidate(expr.right);
-            if (left.kind === 222 /* SyntaxKind.TypeOfExpression */ && isStringLiteralLike(right))
+            if (left.kind === 223 /* SyntaxKind.TypeOfExpression */ && isStringLiteralLike(right))
                 return narrowTypeByTypeof(c, f, t, left, operator, right, assumeTrue);
-            if (right.kind === 222 /* SyntaxKind.TypeOfExpression */ && isStringLiteralLike(left))
+            if (right.kind === 223 /* SyntaxKind.TypeOfExpression */ && isStringLiteralLike(left))
                 return narrowTypeByTypeof(c, f, t, right, operator, left, assumeTrue);
             if (isMatchingReference(c, f.reference, left))
                 return narrowTypeByEquality(c, t, operator, right, assumeTrue);
@@ -1251,7 +1261,7 @@ function isBooleanLiteral(node) {
     return node.kind === 111 /* SyntaxKind.TrueKeyword */ || node.kind === 96 /* SyntaxKind.FalseKeyword */;
 }
 function isAccessExpression(node) {
-    return node.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || node.kind === 213 /* SyntaxKind.ElementAccessExpression */;
+    return node.kind === 213 /* SyntaxKind.PropertyAccessExpression */ || node.kind === 214 /* SyntaxKind.ElementAccessExpression */;
 }
 function isStringLiteralLike(node) {
     return node.kind === 10 /* SyntaxKind.StringLiteral */ || node.kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */;
@@ -1307,13 +1317,59 @@ function narrowTypeByEqualityWorker(c, t, valueType, doubleEquals, assumeTrue) {
             if ((valueType.flags & 1048576 /* TypeFlags.Object */) !== 0)
                 return c.nonPrimitiveType;
         }
+        if (!doubleEquals && (valueType.flags & 12713980 /* TypeFlags.Primitive */) !== 0 && isUniformUnionType(c, t)) {
+            const regularType = getRegularTypeOfLiteralType(c, valueType);
+            if (unionContainsTypeOrPrimitive(c, t, regularType, false))
+                return regularType;
+        }
         const filtered = filterType(c, t, (u) => areTypesComparable(c, u, valueType) || (doubleEquals && isCoercibleUnderDoubleEquals(u, valueType)));
         return replacePrimitivesWithLiterals(c, filtered, valueType);
     }
-    if (isUnitType(valueType))
+    if (isUnitType(valueType)) {
+        if (isUniformUnionType(c, t)) {
+            const filtered = removeType(c, t, getRegularTypeOfLiteralType(c, valueType));
+            if (filtered !== t)
+                return filtered;
+        }
         return filterType(c, t, (u) => !(isUnitLikeType(u) && areTypesComparable(c, u, valueType)));
+    }
     return t;
 }
+/**
+ * Whether `t` is a primitive union in which no two literal constituents are comparable: it has no
+ * literals of two enums, and not both enum literals and string or number literals. Comparing such a
+ * union with one of its literals matches only that literal.
+ */
+function isUniformUnionType(c, t) {
+    if ((t.objectFlags & 32768 /* ObjectFlags.PrimitiveUnion */) === 0)
+        return false;
+    const side = sideOf(c, t);
+    if ((side.objectFlags & 268435456 /* ObjectFlags.IsUniformEnumComputed */) === 0)
+        side.objectFlags |=
+            268435456 /* ObjectFlags.IsUniformEnumComputed */ | (computeIsUniformUnionType(c, typesOf(t)) ? 536870912 /* ObjectFlags.IsUniformEnum */ : 0);
+    return (side.objectFlags & 536870912 /* ObjectFlags.IsUniformEnum */) !== 0;
+}
+function computeIsUniformUnionType(c, types) {
+    let enumSymbol;
+    let hasStringOrNumberLiteral = false;
+    for (const t of types) {
+        if ((t.flags & 98304 /* TypeFlags.EnumLike */) !== 0) {
+            if (hasStringOrNumberLiteral)
+                return false;
+            const parent = getParentOfSymbol(c, t.symbol);
+            if (enumSymbol === undefined)
+                enumSymbol = parent;
+            else if (enumSymbol !== parent)
+                return false;
+        }
+        else if ((t.flags & 3072 /* TypeFlags.StringOrNumberLiteral */) !== 0) {
+            if (enumSymbol !== undefined)
+                return false;
+            hasStringOrNumberLiteral = true;
+        }
+    }
+    return true;
+}
 function isCoercibleUnderDoubleEquals(source, target) {
     return ((source.flags & (64 /* TypeFlags.Number */ | 32 /* TypeFlags.String */ | 8192 /* TypeFlags.BooleanLiteral */)) !== 0 &&
         (target.flags & (64 /* TypeFlags.Number */ | 32 /* TypeFlags.String */ | 256 /* TypeFlags.Boolean */)) !== 0);
@@ -1601,20 +1657,20 @@ function getDiscriminantPropertyAccess(c, f, expr, computedType) {
 }
 function getCandidateDiscriminantPropertyAccess(c, f, expr) {
     const reference = f.reference;
-    if (reference.kind === 207 /* SyntaxKind.ObjectBindingPattern */ ||
-        reference.kind === 208 /* SyntaxKind.ArrayBindingPattern */ ||
-        reference.kind === 219 /* SyntaxKind.FunctionExpression */ ||
-        reference.kind === 220 /* SyntaxKind.ArrowFunction */ ||
+    if (reference.kind === 208 /* SyntaxKind.ObjectBindingPattern */ ||
+        reference.kind === 209 /* SyntaxKind.ArrayBindingPattern */ ||
+        reference.kind === 220 /* SyntaxKind.FunctionExpression */ ||
+        reference.kind === 221 /* SyntaxKind.ArrowFunction */ ||
         isObjectLiteralMethod(reference)) {
         // A pseudo-reference from getNarrowedTypeOfSymbol: a sibling destructured variable or parameter is a candidate.
         if (expr.kind !== 79 /* SyntaxKind.Identifier */)
             return undefined;
         const declaration = getExportSymbolOfValueSymbolIfExported(c, getResolvedSymbol(c, expr)).valueDeclaration;
         if (declaration !== undefined &&
-            (declaration.kind === 209 /* SyntaxKind.BindingElement */ || declaration.kind === 170 /* SyntaxKind.Parameter */) &&
+            (declaration.kind === 210 /* SyntaxKind.BindingElement */ || declaration.kind === 171 /* SyntaxKind.Parameter */) &&
             declaration.parent === reference &&
             getInitializer(declaration) === undefined &&
-            (declaration.kind === 209 /* SyntaxKind.BindingElement */
+            (declaration.kind === 210 /* SyntaxKind.BindingElement */
                 ? declaration.dotDotDotToken
                 : getDotDotDotToken(declaration)) === undefined)
             return declaration;
@@ -1634,7 +1690,7 @@ function getCandidateDiscriminantPropertyAccess(c, f, expr) {
                 return initializer;
             // `const { kind: x } = obj` makes `x` an alias of `obj.kind`.
             if (declaration !== undefined &&
-                declaration.kind === 209 /* SyntaxKind.BindingElement */ &&
+                declaration.kind === 210 /* SyntaxKind.BindingElement */ &&
                 getInitializer(declaration) === undefined) {
                 const parentInitializer = getCandidateVariableDeclarationInitializer(declaration.parent.parent);
                 if (parentInitializer !== undefined &&
@@ -1647,7 +1703,7 @@ function getCandidateDiscriminantPropertyAccess(c, f, expr) {
     return undefined;
 }
 function getCandidateVariableDeclarationInitializer(node) {
-    if (node === undefined || node.kind !== 261 /* SyntaxKind.VariableDeclaration */ || getType(node) !== undefined)
+    if (node === undefined || node.kind !== 262 /* SyntaxKind.VariableDeclaration */ || getType(node) !== undefined)
         return undefined;
     const initializer = getInitializer(node);
     return initializer !== undefined ? skipParentheses(initializer) : undefined;
@@ -1673,7 +1729,7 @@ function narrowTypeByDiscriminant(c, t, access, narrow) {
     });
 }
 function isNonNullAccess(node) {
-    return isAccessExpression(node) && getExpression(node).kind === 236 /* SyntaxKind.NonNullExpression */;
+    return isAccessExpression(node) && getExpression(node).kind === 237 /* SyntaxKind.NonNullExpression */;
 }
 function getTypeOfPropertyOrIndexSignatureOfType(c, t, name) {
     const propType = getTypeOfPropertyOfType(c, t, name);
@@ -1771,7 +1827,7 @@ function getTypeAtSwitchClause(c, f, flow) {
     let t = flowType;
     if (isMatchingReference(c, f.reference, expr))
         t = narrowTypeBySwitchOnDiscriminant(c, t, flow);
-    else if (expr.kind === 222 /* SyntaxKind.TypeOfExpression */ && isMatchingReference(c, f.reference, getExpression(expr)))
+    else if (expr.kind === 223 /* SyntaxKind.TypeOfExpression */ && isMatchingReference(c, f.reference, getExpression(expr)))
         t = narrowTypeBySwitchOnTypeOf(c, t, flow);
     else if (expr.kind === 111 /* SyntaxKind.TrueKeyword */)
         t = narrowTypeBySwitchOnTrue(c, f, t, flow);
@@ -1779,7 +1835,7 @@ function getTypeAtSwitchClause(c, f, flow) {
         if (c.strictNullChecks) {
             if (optionalChainContainsReference(c, expr, f.reference))
                 t = narrowTypeBySwitchOptionalChainContainment(c, t, flow, (u) => (u.flags & (4 /* TypeFlags.Undefined */ | 262144 /* TypeFlags.Never */)) === 0);
-            else if (expr.kind === 222 /* SyntaxKind.TypeOfExpression */ &&
+            else if (expr.kind === 223 /* SyntaxKind.TypeOfExpression */ &&
                 optionalChainContainsReference(c, getExpression(expr), f.reference))
                 t = narrowTypeBySwitchOptionalChainContainment(c, t, flow, (u) => !((u.flags & 262144 /* TypeFlags.Never */) !== 0 ||
                     ((u.flags & 1024 /* TypeFlags.StringLiteral */) !== 0 && u.stringValue === 'undefined')));
@@ -1860,9 +1916,18 @@ function narrowTypeBySwitchOnDiscriminantWorker(c, t, flow) {
         return getUnionType(c, ground);
     }
     const discriminantType = getUnionType(c, clauseTypes);
-    const caseType = (discriminantType.flags & 262144 /* TypeFlags.Never */) !== 0
-        ? c.neverType
-        : replacePrimitivesWithLiterals(c, filterType(c, t, (u) => areTypesComparable(c, discriminantType, u)), discriminantType);
+    let caseType;
+    if ((discriminantType.flags & 262144 /* TypeFlags.Never */) !== 0)
+        caseType = c.neverType;
+    else {
+        if ((discriminantType.flags & 12713980 /* TypeFlags.Primitive */) !== 0 && isUniformUnionType(c, t)) {
+            const regularType = getRegularTypeOfLiteralType(c, discriminantType);
+            if (unionContainsTypeOrPrimitive(c, t, regularType, false))
+                caseType = regularType;
+        }
+        if (caseType === undefined)
+            caseType = replacePrimitivesWithLiterals(c, filterType(c, t, (u) => areTypesComparable(c, discriminantType, u)), discriminantType);
+    }
     if (!hasDefaultClause)
         return caseType;
     const defaultType = filterType(c, t, (u) => {
@@ -1912,7 +1977,7 @@ function getNotEqualFactsFromTypeofSwitch(start, end, witnesses) {
 function getDefaultClauseIndex(statement) {
     const clauses = getClauses(statement);
     for (let i = 0; i < clauses.length; i++)
-        if (clauses[i].kind === 298 /* SyntaxKind.DefaultClause */)
+        if (clauses[i].kind === 299 /* SyntaxKind.DefaultClause */)
             return i;
     return -1;
 }
@@ -1971,7 +2036,7 @@ export function isExhaustiveSwitchStatement(c, statement) {
 }
 function computeExhaustiveSwitchStatement(c, statement) {
     const expression = statement.expression;
-    if (expression.kind === 222 /* SyntaxKind.TypeOfExpression */) {
+    if (expression.kind === 223 /* SyntaxKind.TypeOfExpression */) {
         const witnesses = getSwitchClauseTypeOfWitnesses(c, statement);
         if (witnesses === undefined)
             return false;
@@ -2003,9 +2068,9 @@ export function isMatchingReference(c, source, target) {
     // A declaration's symbol has the declaration's name, and an identifier's text is its name: an
     // identifier never refers to the variable or binding element of a declaration of another name.
     if (source.kind === 79 /* SyntaxKind.Identifier */ &&
-        (target.kind === 261 /* SyntaxKind.VariableDeclaration */ || target.kind === 209 /* SyntaxKind.BindingElement */)) {
+        (target.kind === 262 /* SyntaxKind.VariableDeclaration */ || target.kind === 210 /* SyntaxKind.BindingElement */)) {
         // A cast to one class: a union of the two would be boxed in native builds.
-        const name = target.kind === 261 /* SyntaxKind.VariableDeclaration */
+        const name = target.kind === 262 /* SyntaxKind.VariableDeclaration */
             ? target.name
             : target.name;
         if (name !== undefined &&
@@ -2014,10 +2079,10 @@ export function isMatchingReference(c, source, target) {
             return false;
     }
     switch (target.kind) {
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
-        case 236 /* SyntaxKind.NonNullExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
+        case 237 /* SyntaxKind.NonNullExpression */:
             return isMatchingReference(c, source, getExpression(target));
-        case 227 /* SyntaxKind.BinaryExpression */: {
+        case 228 /* SyntaxKind.BinaryExpression */: {
             const binary = target;
             return ((isAssignmentExpression(target, false) && isMatchingReference(c, source, binary.left)) ||
                 (binary.operatorToken.kind === 27 /* SyntaxKind.CommaToken */ && isMatchingReference(c, source, binary.right)));
@@ -2030,23 +2095,23 @@ export function isMatchingReference(c, source, target) {
                 return target.kind === 109 /* SyntaxKind.ThisKeyword */;
             if (target.kind === 79 /* SyntaxKind.Identifier */)
                 return getResolvedSymbol(c, source) === getResolvedSymbol(c, target);
-            if (target.kind === 261 /* SyntaxKind.VariableDeclaration */ || target.kind === 209 /* SyntaxKind.BindingElement */)
+            if (target.kind === 262 /* SyntaxKind.VariableDeclaration */ || target.kind === 210 /* SyntaxKind.BindingElement */)
                 return (getExportSymbolOfValueSymbolIfExported(c, getResolvedSymbol(c, source)) === getSymbolOfDeclaration(c, target));
             return false;
         case 109 /* SyntaxKind.ThisKeyword */:
             return target.kind === 109 /* SyntaxKind.ThisKeyword */;
         case 107 /* SyntaxKind.SuperKeyword */:
             return target.kind === 107 /* SyntaxKind.SuperKeyword */;
-        case 237 /* SyntaxKind.MetaProperty */:
-            return (target.kind === 237 /* SyntaxKind.MetaProperty */ &&
+        case 238 /* SyntaxKind.MetaProperty */:
+            return (target.kind === 238 /* SyntaxKind.MetaProperty */ &&
                 source.keywordToken === target.keywordToken &&
                 source.name.text === target.name.text);
-        case 236 /* SyntaxKind.NonNullExpression */:
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
-        case 239 /* SyntaxKind.SatisfiesExpression */:
+        case 237 /* SyntaxKind.NonNullExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
+        case 240 /* SyntaxKind.SatisfiesExpression */:
             return isMatchingReference(c, getExpression(source), target);
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-        case 213 /* SyntaxKind.ElementAccessExpression */: {
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */: {
             const sourceName = getAccessedPropertyName(c, source);
             if (sourceName !== undefined && isAccessExpression(target)) {
                 const targetName = getAccessedPropertyName(c, target);
@@ -2054,7 +2119,7 @@ export function isMatchingReference(c, source, target) {
                     return targetName === sourceName && isMatchingReference(c, getExpression(source), getExpression(target));
             }
             // `obj[key]` matches `obj[key]` for a key that isn't reassigned.
-            if (source.kind === 213 /* SyntaxKind.ElementAccessExpression */ && target.kind === 213 /* SyntaxKind.ElementAccessExpression */) {
+            if (source.kind === 214 /* SyntaxKind.ElementAccessExpression */ && target.kind === 214 /* SyntaxKind.ElementAccessExpression */) {
                 const sourceArg = source.argumentExpression;
                 const targetArg = target.argumentExpression;
                 if (sourceArg.kind === 79 /* SyntaxKind.Identifier */ && targetArg.kind === 79 /* SyntaxKind.Identifier */) {
@@ -2065,15 +2130,15 @@ export function isMatchingReference(c, source, target) {
             }
             return false;
         }
-        case 167 /* SyntaxKind.QualifiedName */:
+        case 168 /* SyntaxKind.QualifiedName */:
             if (isAccessExpression(target)) {
                 const targetName = getAccessedPropertyName(c, target);
                 if (targetName !== undefined)
-                    return (source.right.text === targetName &&
+                    return (getText(source.right) === targetName &&
                         isMatchingReference(c, source.left, getExpression(target)));
             }
             return false;
-        case 227 /* SyntaxKind.BinaryExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
             return (source.operatorToken.kind === 27 /* SyntaxKind.CommaToken */ &&
                 isMatchingReference(c, source.right, target));
     }
@@ -2081,9 +2146,14 @@ export function isMatchingReference(c, source, target) {
 }
 /** Whether `expr` is `reference.constructor`. */
 function isMatchingConstructorReference(c, f, expr) {
-    return (isAccessExpression(expr) &&
-        getAccessedPropertyName(c, expr) === 'constructor' &&
-        isMatchingReference(c, f.reference, getExpression(expr)));
+    // Only a literal name is read here; resolving an entity name argument could start a circularity.
+    let name = undefined;
+    if (expr.kind === 213 /* SyntaxKind.PropertyAccessExpression */)
+        name = expr.name;
+    else if (expr.kind === 214 /* SyntaxKind.ElementAccessExpression */ &&
+        isStringLiteralLike(expr.argumentExpression))
+        name = expr.argumentExpression;
+    return (name !== undefined && getText(name) === 'constructor' && isMatchingReference(c, f.reference, getExpression(expr)));
 }
 /** Narrows by `x.constructor === C` to the constituents constructed by `C`. */
 function narrowTypeByConstructor(c, t, operator, identifier, assumeTrue) {
@@ -2117,11 +2187,11 @@ function isConstructedBy(c, source, target) {
     return isTypeSubtypeOf(c, source, target);
 }
 export function getAccessedPropertyName(c, access) {
-    if (access.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+    if (access.kind === 213 /* SyntaxKind.PropertyAccessExpression */)
         return getText(access.name);
-    if (access.kind === 209 /* SyntaxKind.BindingElement */)
+    if (access.kind === 210 /* SyntaxKind.BindingElement */)
         return getDestructuringPropertyName(c, access);
-    if (access.kind === 213 /* SyntaxKind.ElementAccessExpression */) {
+    if (access.kind === 214 /* SyntaxKind.ElementAccessExpression */) {
         const argument = access.argumentExpression;
         if (isStringLiteralLike(argument))
             return getText(argument);
@@ -2130,7 +2200,7 @@ export function getAccessedPropertyName(c, access) {
         if (isEntityNameExpression(argument, false))
             return tryGetNameFromEntityNameExpression(c, argument);
     }
-    if (access.kind === 170 /* SyntaxKind.Parameter */)
+    if (access.kind === 171 /* SyntaxKind.Parameter */)
         return String(getParameters(access.parent).nodes.indexOf(access));
     return undefined;
 }
@@ -2150,16 +2220,16 @@ export function tryGetNameFromEntityNameExpression(c, node) {
     }
     // Binding elements are excluded: their initializers don't alone determine their types, and resolving
     // their full types can be circular.
-    if ((declaration.kind === 261 /* SyntaxKind.VariableDeclaration */ ||
-        declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ ||
-        declaration.kind === 303 /* SyntaxKind.PropertyAssignment */ ||
-        declaration.kind === 170 /* SyntaxKind.Parameter */ ||
-        declaration.kind === 306 /* SyntaxKind.EnumMember */) &&
+    if ((declaration.kind === 262 /* SyntaxKind.VariableDeclaration */ ||
+        declaration.kind === 174 /* SyntaxKind.PropertyDeclaration */ ||
+        declaration.kind === 304 /* SyntaxKind.PropertyAssignment */ ||
+        declaration.kind === 171 /* SyntaxKind.Parameter */ ||
+        declaration.kind === 307 /* SyntaxKind.EnumMember */) &&
         isBlockScopedNameDeclaredBeforeUse(c, declaration, node)) {
         const initializer = getInitializer(declaration);
         if (initializer !== undefined)
             return tryGetNameFromType(getTypeOfExpression(c, initializer));
-        if (declaration.kind === 306 /* SyntaxKind.EnumMember */) {
+        if (declaration.kind === 307 /* SyntaxKind.EnumMember */) {
             const name = getName(declaration);
             if (isStringLiteralLike(name) || name.kind === 8 /* SyntaxKind.NumericLiteral */ || name.kind === 79 /* SyntaxKind.Identifier */)
                 return getText(name);
@@ -2176,11 +2246,11 @@ export function tryGetNameFromType(t) {
 export function getDestructuringPropertyName(c, node) {
     const parent = node.parent;
     let name;
-    if (node.kind === 209 /* SyntaxKind.BindingElement */ && parent.kind === 207 /* SyntaxKind.ObjectBindingPattern */)
+    if (node.kind === 210 /* SyntaxKind.BindingElement */ && parent.kind === 208 /* SyntaxKind.ObjectBindingPattern */)
         name = node.propertyName ?? node.name;
-    else if (node.kind === 303 /* SyntaxKind.PropertyAssignment */ || node.kind === 304 /* SyntaxKind.ShorthandPropertyAssignment */)
+    else if (node.kind === 304 /* SyntaxKind.PropertyAssignment */ || node.kind === 305 /* SyntaxKind.ShorthandPropertyAssignment */)
         name = getName(node);
-    else if (parent.kind === 210 /* SyntaxKind.ArrayLiteralExpression */ || parent.kind === 208 /* SyntaxKind.ArrayBindingPattern */)
+    else if (parent.kind === 211 /* SyntaxKind.ArrayLiteralExpression */ || parent.kind === 209 /* SyntaxKind.ArrayBindingPattern */)
         return String(getElements(parent).nodes.indexOf(node));
     if (name === undefined)
         return undefined;
@@ -2199,24 +2269,24 @@ export function isConstantReference(c, node) {
             const symbol = getResolvedSymbol(c, node);
             return (isConstantVariable(c, symbol) ||
                 (isParameterOrMutableLocalVariable(c, symbol) && !isSymbolAssigned(c, symbol)) ||
-                (symbol.valueDeclaration !== undefined && symbol.valueDeclaration.kind === 219 /* SyntaxKind.FunctionExpression */));
+                (symbol.valueDeclaration !== undefined && symbol.valueDeclaration.kind === 220 /* SyntaxKind.FunctionExpression */));
         }
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-        case 213 /* SyntaxKind.ElementAccessExpression */: {
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */: {
             if (!isConstantReference(c, getExpression(node)))
                 return false;
             const symbol = c.resolvedSymbols.get(node.id);
             return symbol !== undefined && isReadonlySymbol(c, symbol);
         }
-        case 207 /* SyntaxKind.ObjectBindingPattern */:
-        case 208 /* SyntaxKind.ArrayBindingPattern */: {
+        case 208 /* SyntaxKind.ObjectBindingPattern */:
+        case 209 /* SyntaxKind.ArrayBindingPattern */: {
             // A destructuring pseudo-reference is constant when none of its variables are reassigned.
             const rootDeclaration = getRootDeclaration(node.parent);
-            if (rootDeclaration.kind === 170 /* SyntaxKind.Parameter */ ||
-                (rootDeclaration.kind === 261 /* SyntaxKind.VariableDeclaration */ &&
-                    rootDeclaration.parent.kind === 300 /* SyntaxKind.CatchClause */))
+            if (rootDeclaration.kind === 171 /* SyntaxKind.Parameter */ ||
+                (rootDeclaration.kind === 262 /* SyntaxKind.VariableDeclaration */ &&
+                    rootDeclaration.parent.kind === 301 /* SyntaxKind.CatchClause */))
                 return !isSomeSymbolAssigned(c, getName(rootDeclaration));
-            if (rootDeclaration.kind !== 261 /* SyntaxKind.VariableDeclaration */)
+            if (rootDeclaration.kind !== 262 /* SyntaxKind.VariableDeclaration */)
                 return false;
             const blockScopeKind = getCombinedNodeFlags(rootDeclaration) & 7 /* NodeFlags.BlockScoped */;
             return (blockScopeKind === 2 /* NodeFlags.Const */ ||
@@ -2246,9 +2316,9 @@ function optionalChainContainsReference(c, sourceIn, target) {
 }
 function getReferenceCandidate(node) {
     switch (node.kind) {
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
             return getReferenceCandidate(getExpression(node));
-        case 227 /* SyntaxKind.BinaryExpression */: {
+        case 228 /* SyntaxKind.BinaryExpression */: {
             const binary = node;
             switch (binary.operatorToken.kind) {
                 case 63 /* SyntaxKind.EqualsToken */:
@@ -2272,18 +2342,23 @@ export function hasMatchingArgument(c, call, reference) {
                 return true;
     }
     const callee = getExpression(call);
-    return (callee.kind === 212 /* SyntaxKind.PropertyAccessExpression */ &&
+    return (callee.kind === 213 /* SyntaxKind.PropertyAccessExpression */ &&
         isOrContainsMatchingReference(c, reference, getExpression(callee)));
 }
 function isOrContainsMatchingReference(c, source, target) {
     return isMatchingReference(c, source, target) || containsMatchingReference(c, source, target);
 }
 function isCallChain(node) {
-    return node.kind === 214 /* SyntaxKind.CallExpression */ && isOptionalChain(node);
+    return node.kind === 215 /* SyntaxKind.CallExpression */ && isOptionalChain(node);
 }
 // ---- Reachability
 export function isReachableFlowNode(c, flow) {
+    // The reduce labels of an enclosing flow analysis don't apply.
+    const outerReduceLabels = c.flowReduceLabels;
+    if (outerReduceLabels.length !== 0)
+        c.flowReduceLabels = [];
     const result = isReachableFlowNodeWorker(c, flow, false);
+    c.flowReduceLabels = outerReduceLabels;
     c.lastFlowNode = flow;
     c.lastFlowNodeReachable = result;
     return result;
@@ -2296,7 +2371,8 @@ function isReachableFlowNodeWorker(c, start, noCacheCheckIn) {
             return c.lastFlowNodeReachable;
         const flags = flow.flags;
         if ((flags & 4096 /* FlowFlags.Shared */) !== 0) {
-            if (!noCacheCheck) {
+            // A result found through a reduce label holds only for that label's antecedents.
+            if (!noCacheCheck && c.flowReduceLabels.length === 0) {
                 const cached = c.flowNodeReachable.get(flow);
                 if (cached !== undefined)
                     return cached;
@@ -2359,7 +2435,7 @@ function isFalseExpression(expr) {
     const node = skipParentheses(expr);
     if (node.kind === 96 /* SyntaxKind.FalseKeyword */)
         return true;
-    if (node.kind === 227 /* SyntaxKind.BinaryExpression */) {
+    if (node.kind === 228 /* SyntaxKind.BinaryExpression */) {
         const binary = node;
         if (binary.operatorToken.kind === 55 /* SyntaxKind.AmpersandAmpersandToken */)
             return isFalseExpression(binary.left) || isFalseExpression(binary.right);
@@ -2372,13 +2448,13 @@ export function getAssignmentTargetKind(node) {
     const target = getAssignmentTarget(node);
     if (target === undefined)
         return 0 /* AssignmentKind.None */;
-    if (target.kind === 227 /* SyntaxKind.BinaryExpression */) {
+    if (target.kind === 228 /* SyntaxKind.BinaryExpression */) {
         const op = target.operatorToken.kind;
         return op === 63 /* SyntaxKind.EqualsToken */ || isLogicalOrCoalescingAssignmentOperator(op)
             ? 1 /* AssignmentKind.Definite */
             : 2 /* AssignmentKind.Compound */;
     }
-    if (target.kind === 225 /* SyntaxKind.PrefixUnaryExpression */ || target.kind === 226 /* SyntaxKind.PostfixUnaryExpression */)
+    if (target.kind === 226 /* SyntaxKind.PrefixUnaryExpression */ || target.kind === 227 /* SyntaxKind.PostfixUnaryExpression */)
         return 2 /* AssignmentKind.Compound */;
     return 1 /* AssignmentKind.Definite */;
 }
@@ -2387,7 +2463,7 @@ export function isInCompoundLikeAssignment(node) {
     if (target === undefined || !isAssignmentExpression(target, true))
         return false;
     const right = skipParentheses(target.right);
-    return (right.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+    return (right.kind === 228 /* SyntaxKind.BinaryExpression */ &&
         isShiftOperatorOrHigher(right.operatorToken.kind));
 }
 function isShiftOperatorOrHigher(kind) {
@@ -2417,9 +2493,9 @@ export function isParameterOrMutableLocalVariable(_c, symbol) {
     if (symbol.valueDeclaration === undefined)
         return false;
     const declaration = getRootDeclaration(symbol.valueDeclaration);
-    return (declaration.kind === 170 /* SyntaxKind.Parameter */ ||
-        (declaration.kind === 261 /* SyntaxKind.VariableDeclaration */ &&
-            (declaration.parent.kind === 300 /* SyntaxKind.CatchClause */ || isMutableLocalVariableDeclaration(declaration))));
+    return (declaration.kind === 171 /* SyntaxKind.Parameter */ ||
+        (declaration.kind === 262 /* SyntaxKind.VariableDeclaration */ &&
+            (declaration.parent.kind === 301 /* SyntaxKind.CatchClause */ || isMutableLocalVariableDeclaration(declaration))));
 }
 export function isMutableLocalVariableDeclaration(declaration) {
     const list = declaration.parent;
@@ -2428,7 +2504,7 @@ export function isMutableLocalVariableDeclaration(declaration) {
     if ((getCombinedModifierFlags(declaration) & 32 /* ModifierFlags.Export */) !== 0)
         return false;
     const statement = list.parent;
-    return !(statement.kind === 244 /* SyntaxKind.VariableStatement */ && isGlobalSourceFile(statement.parent));
+    return !(statement.kind === 245 /* SyntaxKind.VariableStatement */ && isGlobalSourceFile(statement.parent));
 }
 export function isSymbolAssigned(c, symbol) {
     ensureAssignmentsMarked(c, symbol);
@@ -2445,7 +2521,7 @@ export function isPastLastAssignment(c, symbol, location) {
     return pos === 0 || (location !== undefined && pos < location.pos);
 }
 function isFunctionOrSourceFile(node) {
-    return node.kind === 307 /* SyntaxKind.SourceFile */ || isFunctionLike(node);
+    return node.kind === 308 /* SyntaxKind.SourceFile */ || isFunctionLike(node);
 }
 function findFunctionOrSourceFile(node) {
     let current = node;
@@ -2454,8 +2530,6 @@ function findFunctionOrSourceFile(node) {
     return current;
 }
 function ensureAssignmentsMarked(c, symbol) {
-    if (c.symbolLinks(symbol).lastAssignmentPos !== 0)
-        return;
     const parent = findFunctionOrSourceFile(symbol.valueDeclaration);
     if (parent === undefined)
         return;
@@ -2502,7 +2576,7 @@ export class AssignmentMarker extends NodeVisitor {
                     links.hasDefiniteAssignment = true;
                 return false;
             }
-            case 282 /* SyntaxKind.ExportSpecifier */: {
+            case 283 /* SyntaxKind.ExportSpecifier */: {
                 const specifier = node;
                 const declaration = specifier.parent.parent;
                 const name = specifier.propertyName ?? specifier.name;
@@ -2516,13 +2590,13 @@ export class AssignmentMarker extends NodeVisitor {
                 }
                 return false;
             }
-            case 265 /* SyntaxKind.InterfaceDeclaration */:
-            case 266 /* SyntaxKind.TypeAliasDeclaration */:
-            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
-            case 267 /* SyntaxKind.EnumDeclaration */:
+            case 266 /* SyntaxKind.InterfaceDeclaration */:
+            case 267 /* SyntaxKind.TypeAliasDeclaration */:
+            case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 268 /* SyntaxKind.EnumDeclaration */:
                 return false;
         }
-        if (node.kind >= 183 /* SyntaxKind.FirstTypeNode */ && node.kind <= 206 /* SyntaxKind.LastTypeNode */)
+        if (node.kind >= 184 /* SyntaxKind.FirstTypeNode */ && node.kind <= 207 /* SyntaxKind.LastTypeNode */)
             return false;
         return node.forEachChild(this);
     }
@@ -2532,18 +2606,18 @@ function extendAssignmentPosition(nodeIn, declaration) {
     let pos = nodeIn.pos;
     while (node !== undefined && node.pos > declaration.pos) {
         switch (node.kind) {
-            case 244 /* SyntaxKind.VariableStatement */:
-            case 245 /* SyntaxKind.ExpressionStatement */:
-            case 246 /* SyntaxKind.IfStatement */:
-            case 247 /* SyntaxKind.DoStatement */:
-            case 248 /* SyntaxKind.WhileStatement */:
-            case 249 /* SyntaxKind.ForStatement */:
-            case 250 /* SyntaxKind.ForInStatement */:
-            case 251 /* SyntaxKind.ForOfStatement */:
-            case 255 /* SyntaxKind.WithStatement */:
-            case 256 /* SyntaxKind.SwitchStatement */:
-            case 259 /* SyntaxKind.TryStatement */:
-            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 245 /* SyntaxKind.VariableStatement */:
+            case 246 /* SyntaxKind.ExpressionStatement */:
+            case 247 /* SyntaxKind.IfStatement */:
+            case 248 /* SyntaxKind.DoStatement */:
+            case 249 /* SyntaxKind.WhileStatement */:
+            case 250 /* SyntaxKind.ForStatement */:
+            case 251 /* SyntaxKind.ForInStatement */:
+            case 252 /* SyntaxKind.ForOfStatement */:
+            case 256 /* SyntaxKind.WithStatement */:
+            case 257 /* SyntaxKind.SwitchStatement */:
+            case 260 /* SyntaxKind.TryStatement */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
                 pos = node.end;
         }
         node = node.parent;
@@ -2555,9 +2629,9 @@ export function getControlFlowContainer(node) {
     let current = node.parent;
     for (;;) {
         if ((isFunctionLike(current) && getImmediatelyInvokedFunctionExpression(current) === undefined) ||
-            current.kind === 269 /* SyntaxKind.ModuleBlock */ ||
-            current.kind === 307 /* SyntaxKind.SourceFile */ ||
-            current.kind === 173 /* SyntaxKind.PropertyDeclaration */)
+            current.kind === 270 /* SyntaxKind.ModuleBlock */ ||
+            current.kind === 308 /* SyntaxKind.SourceFile */ ||
+            current.kind === 174 /* SyntaxKind.PropertyDeclaration */)
             return current;
         current = current.parent;
     }
@@ -2567,7 +2641,7 @@ function getTypeAtFlowArrayMutation(c, f, flow) {
     if (f.declaredType !== c.autoType && f.declaredType !== c.autoArrayType)
         return undefined;
     const node = flow.node;
-    const expr = node.kind === 214 /* SyntaxKind.CallExpression */
+    const expr = node.kind === 215 /* SyntaxKind.CallExpression */
         ? getExpression(getExpression(node))
         : getExpression(node.left);
     if (!isMatchingReference(c, f.reference, getReferenceCandidate(expr)))
@@ -2577,7 +2651,7 @@ function getTypeAtFlowArrayMutation(c, f, flow) {
         return flowType;
     const incomplete = f.incomplete;
     let evolvedType = flowType;
-    if (node.kind === 214 /* SyntaxKind.CallExpression */) {
+    if (node.kind === 215 /* SyntaxKind.CallExpression */) {
         for (const arg of getArguments(node).nodes)
             evolvedType = addEvolvingArrayElementType(c, evolvedType, arg);
     }
@@ -2623,17 +2697,17 @@ function isEvolvingArrayTypeList(types) {
 export function isEvolvingArrayOperationTarget(c, node) {
     const root = getReferenceRoot(node);
     const parent = root.parent;
-    if (parent.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+    if (parent.kind === 213 /* SyntaxKind.PropertyAccessExpression */) {
         const name = parent.name;
         return (getText(name) === 'length' ||
-            (parent.parent.kind === 214 /* SyntaxKind.CallExpression */ &&
+            (parent.parent.kind === 215 /* SyntaxKind.CallExpression */ &&
                 name.kind === 79 /* SyntaxKind.Identifier */ &&
                 isPushOrUnshiftIdentifier(name)));
     }
-    if (parent.kind !== 213 /* SyntaxKind.ElementAccessExpression */ || getExpression(parent) !== root)
+    if (parent.kind !== 214 /* SyntaxKind.ElementAccessExpression */ || getExpression(parent) !== root)
         return false;
     const grandparent = parent.parent;
-    return (grandparent.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+    return (grandparent.kind === 228 /* SyntaxKind.BinaryExpression */ &&
         grandparent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ &&
         grandparent.left === parent &&
         !isAssignmentTarget(grandparent) &&
@@ -2641,9 +2715,9 @@ export function isEvolvingArrayOperationTarget(c, node) {
 }
 function getReferenceRoot(node) {
     const parent = node.parent;
-    if (parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+    if (parent.kind === 219 /* SyntaxKind.ParenthesizedExpression */)
         return getReferenceRoot(parent);
-    if (parent.kind === 227 /* SyntaxKind.BinaryExpression */) {
+    if (parent.kind === 228 /* SyntaxKind.BinaryExpression */) {
         const binary = parent;
         if ((binary.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ && binary.left === node) ||
             (binary.operatorToken.kind === 27 /* SyntaxKind.CommaToken */ && binary.right === node))
@@ -2693,12 +2767,12 @@ function reportFlowControlError(c, node) {
         return;
     const file = getSourceFileOfNode(node);
     const span = getRangeOfTokenAtPosition(file, getStatements(block).pos);
-    c.addDiagnostic(new Diagnostic(file.diagnosticFile(), span.pos, span.end, 717 /* Diagnostics.The_containing_function_or_module_body_is_too_large_for_control_flow_analysis */, []));
+    c.addDiagnostic(new Diagnostic(file.diagnosticFile(), span.pos, span.end, 724 /* Diagnostics.The_containing_function_or_module_body_is_too_large_for_control_flow_analysis */, []));
 }
 function isFunctionOrModuleBlock(node) {
-    return (node.kind === 307 /* SyntaxKind.SourceFile */ ||
-        node.kind === 269 /* SyntaxKind.ModuleBlock */ ||
-        (node.kind === 242 /* SyntaxKind.Block */ && node.parent !== undefined && isFunctionLike(node.parent)));
+    return (node.kind === 308 /* SyntaxKind.SourceFile */ ||
+        node.kind === 270 /* SyntaxKind.ModuleBlock */ ||
+        (node.kind === 243 /* SyntaxKind.Block */ && node.parent !== undefined && isFunctionLike(node.parent)));
 }
 /**
  * The type of `symbol` at `location`. A destructured variable of a const declaration or unassigned
@@ -2709,13 +2783,13 @@ export function getNarrowedTypeOfSymbol(c, symbol, location) {
     const t = getTypeOfSymbol(c, symbol);
     const declaration = symbol.valueDeclaration;
     if (declaration !== undefined &&
-        declaration.kind === 170 /* SyntaxKind.Parameter */ &&
+        declaration.kind === 171 /* SyntaxKind.Parameter */ &&
         getType(declaration) === undefined &&
         getInitializer(declaration) === undefined &&
         getDotDotDotToken(declaration) === undefined)
         return getNarrowedTypeOfDependentParameter(c, t, declaration, location);
     if (declaration === undefined ||
-        declaration.kind !== 209 /* SyntaxKind.BindingElement */ ||
+        declaration.kind !== 210 /* SyntaxKind.BindingElement */ ||
         getInitializer(declaration) !== undefined ||
         declaration.dotDotDotToken !== undefined ||
         getElements(declaration.parent).nodes.length < 2)
@@ -2723,11 +2797,20 @@ export function getNarrowedTypeOfSymbol(c, symbol, location) {
     const pattern = declaration.parent;
     const parent = pattern.parent;
     const rootDeclaration = getRootDeclaration(parent);
-    const isParameter = rootDeclaration.kind === 170 /* SyntaxKind.Parameter */;
+    const isParameter = rootDeclaration.kind === 171 /* SyntaxKind.Parameter */;
     if (!isParameter &&
-        !(rootDeclaration.kind === 261 /* SyntaxKind.VariableDeclaration */ &&
+        !(rootDeclaration.kind === 262 /* SyntaxKind.VariableDeclaration */ &&
             (getCombinedNodeFlags(rootDeclaration) & 6 /* NodeFlags.Constant */) !== 0))
         return t;
+    // A reference in the declaration's own initializer would need the declaration's type; defaults of
+    // the binding elements and nested functions are narrowed.
+    const rootInitializer = getInitializer(rootDeclaration);
+    if (rootInitializer !== undefined &&
+        location.pos >= rootInitializer.pos &&
+        location.end <= rootInitializer.end &&
+        isNodeDescendantOf(location, rootInitializer) &&
+        getControlFlowContainer(declaration) === getControlFlowContainer(location))
+        return t;
     const links = c.nodeLinks(parent);
     if ((links.flags & 4194304 /* NodeCheckFlags.InCheckIdentifier */) !== 0)
         return t;
@@ -2735,6 +2818,8 @@ export function getNarrowedTypeOfSymbol(c, symbol, location) {
     let result = t;
     const parentType = getTypeForBindingElementParent(c, parent, 0 /* CheckMode.Normal */);
     const parentTypeConstraint = parentType !== undefined ? mapToBaseConstraintOrType(c, parentType) : undefined;
+    // Only the parent's type is guarded; flow analysis may narrow the binding elements again.
+    links.flags &= ~4194304 /* NodeCheckFlags.InCheckIdentifier */;
     if (parentTypeConstraint !== undefined &&
         (parentTypeConstraint.flags & 134217728 /* TypeFlags.Union */) !== 0 &&
         !(isParameter && isSomeSymbolAssigned(c, getName(rootDeclaration)))) {
@@ -2745,7 +2830,6 @@ export function getNarrowedTypeOfSymbol(c, symbol, location) {
                 ? c.neverType
                 : getBindingElementTypeFromParentType(c, declaration, narrowedType, true);
     }
-    links.flags &= ~4194304 /* NodeCheckFlags.InCheckIdentifier */;
     return result;
 }
 /**