tsc-ts 0.0.10 → 0.1.1

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

@@ -2,7 +2,7 @@
 // values, alias targets and module exports, like tsgo's checker services. These answer *some*
 // symbol or type for any node; the checker itself uses the precise functions they call.
 import { getArguments, getExpression, getInitializer, getName, getParameters, getPropertyName, getSymbol, getTagName, getText, getType, getTypeArguments, isDeclarationNode, NodeVisitor, } from './ast.js';
-import { compareNodePositions, getExternalModuleName, isAssignmentOperator, isFunctionLike, isImportCall, isLiteralImportTypeNode, isStringLiteralLike, isTypeDeclaration, nodeIsMissing, } from './ast-utilities.js';
+import { compareNodePositions, getExternalModuleName, isAssignmentOperator, isFunctionLike, isImportCall, isLiteralImportTypeNode, isNameOfHeritageClauseTypeReference, isStringLiteralLike, isTypeDeclaration, nodeIsMissing, isImportPhaseMetaProperty, } from './ast-utilities.js';
 import { getNameOfDeclaration, getSourceFileOfNode, getThisContainer, isAssignmentTarget, isBindableObjectDefinePropertyCall, isClassLike, isEnumConst, isExternalOrCommonJSModule, isVariableDeclarationInitializedToRequire, } from './binder-utilities.js';
 import { getResolvedSignature, tryGetRestTypeOfSignature } from './checker-calls.js';
 import { getContextualType } from './checker-contextual.js';
@@ -10,7 +10,7 @@ import { computeEnumMemberValues, getBaseTypes, getDeclaredTypeOfClassOrInterfac
 import { checkExpression, checkExpressionCached, checkPropertyAccessExpression, checkQualifiedName, isThisInTypeQuery, } from './checker-expressions.js';
 import { getIntrinsicTagSymbol, isJsxIntrinsicTagName } from './checker-jsx.js';
 import { getApplicableIndexInfo, getIndexInfosOfType, getPropertyOfType, getTypeWithThisArgument, isApplicableIndexType, } from './checker-members.js';
-import { checkNewTargetMetaProperty, getExternalModuleMember, getHostSignatureFromJSDoc, getSymbolOfPartOfRightHandSideOfImportEquals, getTargetOfAliasDeclaration, resolveExternalModuleName, resolveJSDocMemberName, } from './checker-modules.js';
+import { checkNewTargetMetaProperty, getExternalModuleMember, getHostSignatureFromJSDoc, getSymbolOfPartOfRightHandSideOfImportEquals, getTargetOfAliasDeclaration, resolveExternalModuleName, resolveJSDocMemberName, checkImportAttributesExpression, getImportAttributesTypeForModuleSpecifier, } from './checker-modules.js';
 import { getSymbolHasInstanceMethodOfObjectType } from './checker-operators.js';
 import { getSymbolForPrivateIdentifierExpression } from './checker-property-access.js';
 import { getSignatureFromDeclaration } from './checker-signatures.js';
@@ -29,7 +29,7 @@ export function getSymbolAtLocation(c, node) {
 }
 /** The symbol a node refers to, reporting resolution errors unless `ignoreErrors`. */
 export function getSymbolAtLocationWorker(c, node, ignoreErrors) {
-    if (node.kind === 307 /* SyntaxKind.SourceFile */)
+    if (node.kind === 308 /* SyntaxKind.SourceFile */)
         return isExternalOrCommonJSModule(node) ? getSymbolOfDeclaration(c, node) : undefined;
     const parent = node.parent;
     const grandParent = parent.parent;
@@ -47,14 +47,14 @@ export function getSymbolAtLocationWorker(c, node, ignoreErrors) {
     if (node.kind === 79 /* SyntaxKind.Identifier */) {
         if (isInRightSideOfImportOrExportAssignment(node))
             return getSymbolOfNameOrPropertyAccessExpression(c, node);
-        if (parent.kind === 209 /* SyntaxKind.BindingElement */ &&
-            grandParent.kind === 207 /* SyntaxKind.ObjectBindingPattern */ &&
+        if (parent.kind === 210 /* SyntaxKind.BindingElement */ &&
+            grandParent.kind === 208 /* SyntaxKind.ObjectBindingPattern */ &&
             node === getPropertyName(parent)) {
             const property = getPropertyOfType(c, getTypeOfNode(c, grandParent), getText(node));
             if (property !== undefined)
                 return property;
         }
-        else if (parent.kind === 237 /* SyntaxKind.MetaProperty */ && parent.name === node) {
+        else if (parent.kind === 238 /* SyntaxKind.MetaProperty */ && parent.name === node) {
             const meta = parent;
             // `target` in `new.target`.
             if (meta.keywordToken === 104 /* SyntaxKind.NewKeyword */ && getText(node) === 'target')
@@ -65,7 +65,7 @@ export function getSymbolAtLocationWorker(c, node, ignoreErrors) {
             // Other meta properties are invalid syntax.
             return undefined;
         }
-        else if (parent.kind === 333 /* SyntaxKind.JSDocParameterTag */ && getName(parent) === node) {
+        else if (parent.kind === 334 /* SyntaxKind.JSDocParameterTag */ && getName(parent) === node) {
             const fn = getNodeAtPosition(getSourceFileOfNode(node), node.pos, false);
             if (isFunctionLike(fn)) {
                 for (const param of getParameters(fn).nodes) {
@@ -79,20 +79,20 @@ export function getSymbolAtLocationWorker(c, node, ignoreErrors) {
     switch (node.kind) {
         case 79 /* SyntaxKind.Identifier */:
         case 80 /* SyntaxKind.PrivateIdentifier */:
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-        case 167 /* SyntaxKind.QualifiedName */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 168 /* SyntaxKind.QualifiedName */:
             if (!isThisInTypeQuery(node))
                 return getSymbolOfNameOrPropertyAccessExpression(c, node);
             return getSymbolOfThis(c, node);
         case 109 /* SyntaxKind.ThisKeyword */:
             return getSymbolOfThis(c, node);
-        case 198 /* SyntaxKind.ThisType */:
+        case 199 /* SyntaxKind.ThisType */:
             return getTypeFromThisTypeNode(c, node).symbol;
         case 107 /* SyntaxKind.SuperKeyword */:
             return checkExpression(c, node).symbol;
         case 136 /* SyntaxKind.ConstructorKeyword */:
             // The keyword of a constructor overload.
-            return parent.kind === 177 /* SyntaxKind.Constructor */ ? getSymbol(parent.parent) : undefined;
+            return parent.kind === 178 /* SyntaxKind.Constructor */ ? getSymbol(parent.parent) : undefined;
         case 10 /* SyntaxKind.StringLiteral */:
         case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
             // Module names: `import x = require("m")`, import and export declarations, `require("m")`,
@@ -100,18 +100,18 @@ export function getSymbolAtLocationWorker(c, node, ignoreErrors) {
             if ((grandParent !== undefined &&
                 isExternalModuleImportEqualsDeclaration(grandParent) &&
                 grandParent.moduleReference.expression === node) ||
-                ((parent.kind === 273 /* SyntaxKind.ImportDeclaration */ ||
-                    parent.kind === 346 /* SyntaxKind.JSImportDeclaration */ ||
-                    parent.kind === 279 /* SyntaxKind.ExportDeclaration */) &&
+                ((parent.kind === 274 /* SyntaxKind.ImportDeclaration */ ||
+                    parent.kind === 347 /* SyntaxKind.JSImportDeclaration */ ||
+                    parent.kind === 280 /* SyntaxKind.ExportDeclaration */) &&
                     getExternalModuleName(parent) === node) ||
                 (grandParent !== undefined && isVariableDeclarationInitializedToRequire(grandParent)) ||
                 isImportCall(parent) ||
-                (parent.kind === 202 /* SyntaxKind.LiteralType */ &&
+                (parent.kind === 203 /* SyntaxKind.LiteralType */ &&
                     grandParent !== undefined &&
                     isLiteralImportTypeNode(grandParent) &&
                     grandParent.argument === parent))
-                return resolveExternalModuleName(c, node, node, ignoreErrors);
-            if (parent.kind === 214 /* SyntaxKind.CallExpression */ &&
+                return resolveExternalModuleName(c, node, node, ignoreErrors, getImportAttributesTypeForModuleSpecifier(c, node));
+            if (parent.kind === 215 /* SyntaxKind.CallExpression */ &&
                 isBindableObjectDefinePropertyCall(parent) &&
                 getArguments(parent).nodes[1] === node)
                 return getSymbolOfDeclaration(c, parent);
@@ -123,20 +123,20 @@ export function getSymbolAtLocationWorker(c, node, ignoreErrors) {
         case 38 /* SyntaxKind.EqualsGreaterThanToken */:
         case 85 /* SyntaxKind.ClassKeyword */:
             return getSymbolOfDeclaration(c, parent);
-        case 206 /* SyntaxKind.ImportType */:
+        case 207 /* SyntaxKind.ImportType */:
             if (isLiteralImportTypeNode(node))
                 return getSymbolAtLocationWorker(c, node.argument.literal, ignoreErrors);
             return undefined;
         case 94 /* SyntaxKind.ExportKeyword */:
-            return parent.kind === 278 /* SyntaxKind.ExportAssignment */ ? getSymbol(parent) : undefined;
+            return parent.kind === 279 /* SyntaxKind.ExportAssignment */ ? getSymbol(parent) : undefined;
         case 101 /* SyntaxKind.ImportKeyword */:
-            if (parent.kind === 237 /* SyntaxKind.MetaProperty */ && parent.name.text === 'defer')
+            if (isImportPhaseMetaProperty(parent))
                 return undefined;
-            return parent.kind === 237 /* SyntaxKind.MetaProperty */ ? checkMetaPropertyKeyword(c).symbol : undefined;
+            return parent.kind === 238 /* SyntaxKind.MetaProperty */ ? checkMetaPropertyKeyword(c).symbol : undefined;
         case 104 /* SyntaxKind.NewKeyword */:
-            return parent.kind === 237 /* SyntaxKind.MetaProperty */ ? checkMetaPropertyKeyword(c).symbol : undefined;
+            return parent.kind === 238 /* SyntaxKind.MetaProperty */ ? checkMetaPropertyKeyword(c).symbol : undefined;
         case 103 /* SyntaxKind.InstanceOfKeyword */:
-            if (parent.kind === 227 /* SyntaxKind.BinaryExpression */) {
+            if (parent.kind === 228 /* SyntaxKind.BinaryExpression */) {
                 const t = checkExpressionCached(c, parent.right);
                 const hasInstanceMethodType = getSymbolHasInstanceMethodOfObjectType(c, t);
                 if (hasInstanceMethodType !== undefined && hasInstanceMethodType.symbol !== undefined)
@@ -144,9 +144,9 @@ export function getSymbolAtLocationWorker(c, node, ignoreErrors) {
                 return t.symbol;
             }
             return undefined;
-        case 237 /* SyntaxKind.MetaProperty */:
+        case 238 /* SyntaxKind.MetaProperty */:
             return checkExpression(c, node).symbol;
-        case 296 /* SyntaxKind.JsxNamespacedName */:
+        case 297 /* SyntaxKind.JsxNamespacedName */:
             if (isJsxTagName(node) && isJsxIntrinsicTagName(node)) {
                 const symbol = getIntrinsicTagSymbol(c, parent);
                 return symbol === c.unknownSymbol ? undefined : symbol;
@@ -171,11 +171,11 @@ function getSymbolOfThis(c, node) {
 function getSymbolOfLiteralIndex(c, node) {
     const parent = node.parent;
     let objectType;
-    if (parent.kind === 213 /* SyntaxKind.ElementAccessExpression */) {
+    if (parent.kind === 214 /* SyntaxKind.ElementAccessExpression */) {
         if (parent.argumentExpression === node)
             objectType = checkExpressionCached(c, parent.expression);
     }
-    else if (parent.kind === 202 /* SyntaxKind.LiteralType */ && parent.parent.kind === 200 /* SyntaxKind.IndexedAccessType */)
+    else if (parent.kind === 203 /* SyntaxKind.LiteralType */ && parent.parent.kind === 201 /* SyntaxKind.IndexedAccessType */)
         objectType = getTypeFromTypeNode(c, parent.parent.objectType);
     return objectType !== undefined ? getPropertyOfType(c, objectType, getText(node)) : undefined;
 }
@@ -183,7 +183,7 @@ function getSymbolOfNameOrPropertyAccessExpression(c, nameIn) {
     let name = nameIn;
     if (isDeclarationName(name))
         return getSymbolOfDeclaration(c, name.parent);
-    if (name.parent.kind === 278 /* SyntaxKind.ExportAssignment */ && isEntityNameExpression(name)) {
+    if (name.parent.kind === 279 /* SyntaxKind.ExportAssignment */ && isEntityNameExpression(name)) {
         // An entity name that doesn't resolve as one may still check as a property access.
         const meaning = 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 2097152 /* SymbolFlags.Alias */;
         const success = resolveEntityName(c, name, meaning, true, false, undefined);
@@ -204,10 +204,11 @@ function getSymbolOfNameOrPropertyAccessExpression(c, nameIn) {
     }
     while (isRightSideOfQualifiedNameOrPropertyAccess(name))
         name = name.parent;
-    if (isInNameOfExpressionWithTypeArguments(name)) {
+    if (isInNameOfExpressionWithTypeArgumentsOrHeritageTypeReference(name)) {
         let meaning;
-        if (name.parent.kind === 234 /* SyntaxKind.ExpressionWithTypeArguments */) {
-            // `extends Bar<T>` in an interface is a type, `foo<T>` a value, and a class `extends` both.
+        if (name.parent.kind === 235 /* SyntaxKind.ExpressionWithTypeArguments */ ||
+            name.parent.kind === 185 /* SyntaxKind.TypeReference */) {
+            // A heritage element name is a type, `foo<T>` a value, and a class `extends` both.
             meaning = isPartOfTypeNode(name) ? 788968 /* SymbolFlags.Type */ : 111551 /* SymbolFlags.Value */;
             if (isExpressionWithTypeArgumentsInClassExtendsClause(name.parent))
                 meaning |= 111551 /* SymbolFlags.Value */;
@@ -252,11 +253,11 @@ function getSymbolOfNameOrPropertyAccessExpression(c, nameIn) {
         }
         if (name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
             return getSymbolForPrivateIdentifierExpression(c, name);
-        if (name.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || name.kind === 167 /* SyntaxKind.QualifiedName */) {
+        if (name.kind === 213 /* SyntaxKind.PropertyAccessExpression */ || name.kind === 168 /* SyntaxKind.QualifiedName */) {
             const cached = c.resolvedSymbols.get(name.id);
             if (cached !== undefined)
                 return cached;
-            if (name.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+            if (name.kind === 213 /* SyntaxKind.PropertyAccessExpression */) {
                 const access = name;
                 checkPropertyAccessExpression(c, access, false);
                 if (c.resolvedSymbols.get(name.id) === undefined && access.name.kind !== 80 /* SyntaxKind.PrivateIdentifier */)
@@ -264,19 +265,21 @@ function getSymbolOfNameOrPropertyAccessExpression(c, nameIn) {
             }
             else
                 checkQualifiedName(c, name);
-            if (c.resolvedSymbols.get(name.id) === undefined && isJSDoc && name.kind === 167 /* SyntaxKind.QualifiedName */)
+            if (c.resolvedSymbols.get(name.id) === undefined && isJSDoc && name.kind === 168 /* SyntaxKind.QualifiedName */)
                 return resolveJSDocMemberName(c, name);
             return c.resolvedSymbols.get(name.id);
         }
     }
     else if (isEntityName(name) && isTypeReferenceIdentifier(name)) {
-        const meaning = name.parent.kind === 184 /* SyntaxKind.TypeReference */ ? 788968 /* SymbolFlags.Type */ : 1920 /* SymbolFlags.Namespace */;
+        const meaning = name.parent.kind === 185 /* SyntaxKind.TypeReference */ ? 788968 /* SymbolFlags.Type */ : 1920 /* SymbolFlags.Namespace */;
         const symbol = resolveEntityName(c, name, meaning, true, true, undefined);
         if (symbol !== undefined && symbol !== c.unknownSymbol)
             return symbol;
+        if (isNameOfHeritageClauseTypeReference(name))
+            return undefined;
         return getUnresolvedSymbolForEntityName(c, name);
     }
-    if (name.parent.kind === 183 /* SyntaxKind.TypePredicate */)
+    if (name.parent.kind === 184 /* SyntaxKind.TypePredicate */)
         return resolveEntityName(c, name, 1 /* SymbolFlags.FunctionScopedVariable */, true, false, undefined);
     return undefined;
 }
@@ -294,7 +297,7 @@ function getApplicableIndexSymbol(c, t, keyType) {
                 if (other.declaration !== undefined && isApplicableIndexType(c, keyType, other.keyType))
                     declarations.push(other.declaration);
         if (declarations.length !== 0) {
-            const symbol = c.newSymbolWithCheckFlags(4 /* SymbolFlags.Property */, "\uFFFEindex" /* InternalSymbolName.Index */, 8388608 /* CheckFlags.IndexSymbol */);
+            const symbol = c.newSymbolWithCheckFlags(4 /* SymbolFlags.Property */, "\uFFFEindex" /* InternalSymbolName.Index */, 67108864 /* CheckFlags.IndexSymbol */);
             setDeclarations(symbol, declarations);
             symbol.valueDeclaration = declarations[0];
             symbol.parent = t.symbol;
@@ -329,13 +332,13 @@ function checkMetaPropertyKeyword(c) {
 export function getTypeAtLocation(c, node) {
     return getTypeOfNode(c, getReparsedNodeForNode(node));
 }
-function getTypeOfNode(c, node) {
-    if (node.kind === 307 /* SyntaxKind.SourceFile */ && !isExternalOrCommonJSModule(node))
+export function getTypeOfNode(c, node) {
+    if (node.kind === 308 /* SyntaxKind.SourceFile */ && !isExternalOrCommonJSModule(node))
         return c.errorType;
     // Semantic questions inside `with` blocks have no answer.
     if ((node.flags & 16777216 /* NodeFlags.InWithStatement */) !== 0)
         return c.errorType;
-    const heritage = getClassOfHeritageExpression(node);
+    const heritage = getClassOfHeritageElement(node);
     const classType = heritage !== undefined ? getDeclaredTypeOfClassOrInterface(c, getSymbolOfDeclaration(c, heritage)) : undefined;
     if (isPartOfTypeNode(node)) {
         const typeFromTypeNode = getTypeFromTypeNode(c, node);
@@ -356,7 +359,7 @@ function getTypeOfNode(c, node) {
         const symbol = getSymbolAtLocationWorker(c, node, false);
         return symbol !== undefined ? getDeclaredTypeOfSymbol(c, symbol) : c.errorType;
     }
-    if (node.kind === 209 /* SyntaxKind.BindingElement */)
+    if (node.kind === 210 /* SyntaxKind.BindingElement */)
         return getTypeForVariableLikeDeclaration(c, node, true) ?? c.errorType;
     if (isDeclaration(node)) {
         const symbol = getSymbolOfDeclaration(c, node);
@@ -377,11 +380,11 @@ function getTypeOfNode(c, node) {
     }
     const parent = node.parent;
     if (parent !== undefined &&
-        parent.kind === 237 /* SyntaxKind.MetaProperty */ &&
+        parent.kind === 238 /* SyntaxKind.MetaProperty */ &&
         parent.keywordToken === node.kind)
         return checkMetaPropertyKeyword(c);
-    if (node.kind === 301 /* SyntaxKind.ImportAttributes */)
-        return getCachedGlobalType(c, 'ImportAttributes', 0, true);
+    if (node.kind === 302 /* SyntaxKind.ImportAttributes */)
+        return checkImportAttributesExpression(c, node);
     return c.errorType;
 }
 function getRegularTypeOfExpression(c, node) {
@@ -396,8 +399,8 @@ export function getTypeOfSymbolAtLocation(c, symbolIn, locationIn) {
         // A reference to the symbol that isn't only assigned to has a flow type.
         if ((location.kind === 79 /* SyntaxKind.Identifier */ || location.kind === 80 /* SyntaxKind.PrivateIdentifier */) &&
             !(isJsxTagName(location) ||
-                location.parent.kind === 292 /* SyntaxKind.JsxAttribute */ ||
-                location.parent.kind === 296 /* SyntaxKind.JsxNamespacedName */)) {
+                location.parent.kind === 293 /* SyntaxKind.JsxAttribute */ ||
+                location.parent.kind === 297 /* SyntaxKind.JsxNamespacedName */)) {
             if (isRightSideOfQualifiedNameOrPropertyAccess(location))
                 location = location.parent;
             if (isExpressionNode(location) && (!isAssignmentTarget(location) || isWriteAccess(location))) {
@@ -408,7 +411,7 @@ export function getTypeOfSymbolAtLocation(c, symbolIn, locationIn) {
             }
         }
         if (isDeclarationName(location) &&
-            location.parent.kind === 179 /* SyntaxKind.SetAccessor */ &&
+            location.parent.kind === 180 /* SyntaxKind.SetAccessor */ &&
             getAnnotatedAccessorTypeNode(location.parent) !== undefined)
             return getWriteTypeOfAccessors(c, getSymbol(location.parent));
         // A hypothetical reference has no flow information, so it gets the declared type.
@@ -420,14 +423,14 @@ export function getTypeOfSymbolAtLocation(c, symbolIn, locationIn) {
 // ---- Other queries
 /** The value symbol of a shorthand property assignment's name. */
 export function getShorthandAssignmentValueSymbol(c, node) {
-    if (node === undefined || node.kind !== 304 /* SyntaxKind.ShorthandPropertyAssignment */)
+    if (node === undefined || node.kind !== 305 /* SyntaxKind.ShorthandPropertyAssignment */)
         return undefined;
     return resolveEntityName(c, node.name, 111551 /* SymbolFlags.Value */ | 2097152 /* SymbolFlags.Alias */, true, false, undefined);
 }
 /** The local symbol an export specifier, or the identifier of one, refers to. Throws for other nodes. */
 export function getExportSpecifierLocalTargetSymbol(c, node) {
     const meaning = 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 2097152 /* SymbolFlags.Alias */;
-    if (node.kind === 282 /* SyntaxKind.ExportSpecifier */) {
+    if (node.kind === 283 /* SyntaxKind.ExportSpecifier */) {
         const exportDeclaration = node.parent.parent;
         if (getExternalModuleName(exportDeclaration) !== undefined)
             return getExternalModuleMember(c, exportDeclaration, node, false);
@@ -444,7 +447,7 @@ export function getExportSpecifierLocalTargetSymbol(c, node) {
 }
 /** The value of an enum member, or of a reference to a const enum member. */
 export function getConstantValue(c, node) {
-    if (node.kind === 306 /* SyntaxKind.EnumMember */)
+    if (node.kind === 307 /* SyntaxKind.EnumMember */)
         return getEnumMemberValue(c, node);
     // Checking the expression records the symbol it resolves to.
     if (c.resolvedSymbols.get(node.id) === undefined)
@@ -511,14 +514,14 @@ export function querySignatureFromDeclaration(c, node) {
 /** The signature a call-like expression resolves to. Throws for other nodes. */
 export function queryResolvedSignature(c, node) {
     switch (node.kind) {
-        case 214 /* SyntaxKind.CallExpression */:
-        case 215 /* SyntaxKind.NewExpression */:
-        case 216 /* SyntaxKind.TaggedTemplateExpression */:
-        case 171 /* SyntaxKind.Decorator */:
-        case 290 /* SyntaxKind.JsxOpeningFragment */:
-        case 287 /* SyntaxKind.JsxOpeningElement */:
-        case 286 /* SyntaxKind.JsxSelfClosingElement */:
-        case 227 /* SyntaxKind.BinaryExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
+        case 216 /* SyntaxKind.NewExpression */:
+        case 217 /* SyntaxKind.TaggedTemplateExpression */:
+        case 172 /* SyntaxKind.Decorator */:
+        case 291 /* SyntaxKind.JsxOpeningFragment */:
+        case 288 /* SyntaxKind.JsxOpeningElement */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
+        case 228 /* SyntaxKind.BinaryExpression */:
             return getResolvedSignature(c, node, 0 /* CheckMode.Normal */);
     }
     throw new Error('getResolvedSignature expects a call-like expression');
@@ -601,31 +604,31 @@ class ChildCollector extends NodeVisitor {
     }
 }
 export function isEntityName(node) {
-    return node.kind === 79 /* SyntaxKind.Identifier */ || node.kind === 167 /* SyntaxKind.QualifiedName */;
+    return node.kind === 79 /* SyntaxKind.Identifier */ || node.kind === 168 /* SyntaxKind.QualifiedName */;
 }
 function isBindingPattern(node) {
-    return node.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 208 /* SyntaxKind.ArrayBindingPattern */;
+    return node.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 209 /* SyntaxKind.ArrayBindingPattern */;
 }
 function isImportOrExportSpecifier(node) {
-    return node.kind === 277 /* SyntaxKind.ImportSpecifier */ || node.kind === 282 /* SyntaxKind.ExportSpecifier */;
+    return node.kind === 278 /* SyntaxKind.ImportSpecifier */ || node.kind === 283 /* SyntaxKind.ExportSpecifier */;
 }
 function isClassOrInterfaceLike(node) {
-    return (node.kind === 264 /* SyntaxKind.ClassDeclaration */ ||
-        node.kind === 232 /* SyntaxKind.ClassExpression */ ||
-        node.kind === 265 /* SyntaxKind.InterfaceDeclaration */);
+    return (node.kind === 265 /* SyntaxKind.ClassDeclaration */ ||
+        node.kind === 233 /* SyntaxKind.ClassExpression */ ||
+        node.kind === 266 /* SyntaxKind.InterfaceDeclaration */);
 }
 function isJSDocLinkLike(node) {
-    return (node.kind === 319 /* SyntaxKind.JSDocLink */ ||
-        node.kind === 320 /* SyntaxKind.JSDocLinkCode */ ||
-        node.kind === 321 /* SyntaxKind.JSDocLinkPlain */);
+    return (node.kind === 320 /* SyntaxKind.JSDocLink */ ||
+        node.kind === 321 /* SyntaxKind.JSDocLinkCode */ ||
+        node.kind === 322 /* SyntaxKind.JSDocLinkPlain */);
 }
 export function isDeclaration(node) {
-    if (node.kind === 169 /* SyntaxKind.TypeParameter */)
+    if (node.kind === 170 /* SyntaxKind.TypeParameter */)
         return node.parent !== undefined;
     return isDeclarationNode(node);
 }
 export function isDeclarationName(name) {
-    return (name.kind !== 307 /* SyntaxKind.SourceFile */ &&
+    return (name.kind !== 308 /* SyntaxKind.SourceFile */ &&
         !isBindingPattern(name) &&
         isDeclaration(name.parent) &&
         getName(name.parent) === name);
@@ -638,48 +641,48 @@ function isDeclarationNameOrImportPropertyName(name) {
 }
 export function isLiteralComputedPropertyDeclarationName(node) {
     return ((isStringLiteralLike(node) || node.kind === 8 /* SyntaxKind.NumericLiteral */) &&
-        node.parent.kind === 168 /* SyntaxKind.ComputedPropertyName */ &&
+        node.parent.kind === 169 /* SyntaxKind.ComputedPropertyName */ &&
         isDeclaration(node.parent.parent));
 }
 function isExternalModuleImportEqualsDeclaration(node) {
-    return (node.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */ &&
-        node.moduleReference.kind === 284 /* SyntaxKind.ExternalModuleReference */);
+    return (node.kind === 273 /* SyntaxKind.ImportEqualsDeclaration */ &&
+        node.moduleReference.kind === 285 /* SyntaxKind.ExternalModuleReference */);
 }
 export function isInRightSideOfImportOrExportAssignment(nodeIn) {
     let node = nodeIn;
-    while (node.parent.kind === 167 /* SyntaxKind.QualifiedName */)
+    while (node.parent.kind === 168 /* SyntaxKind.QualifiedName */)
         node = node.parent;
     const parent = node.parent;
-    return ((parent.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */ &&
+    return ((parent.kind === 273 /* SyntaxKind.ImportEqualsDeclaration */ &&
         parent.moduleReference === node) ||
-        (parent.kind === 278 /* SyntaxKind.ExportAssignment */ && getExpression(parent) === node));
+        (parent.kind === 279 /* SyntaxKind.ExportAssignment */ && getExpression(parent) === node));
 }
 /** The `import()` type whose qualifier contains `node`. */
 function isImportTypeQualifierPart(nodeIn) {
     let node = nodeIn;
     let parent = node.parent;
-    while (parent !== undefined && parent.kind === 167 /* SyntaxKind.QualifiedName */) {
+    while (parent !== undefined && parent.kind === 168 /* SyntaxKind.QualifiedName */) {
         node = parent;
         parent = parent.parent;
     }
-    if (parent !== undefined && parent.kind === 206 /* SyntaxKind.ImportType */ && parent.qualifier === node)
+    if (parent !== undefined && parent.kind === 207 /* SyntaxKind.ImportType */ && parent.qualifier === node)
         return parent;
     return undefined;
 }
-function isInNameOfExpressionWithTypeArguments(nodeIn) {
+function isInNameOfExpressionWithTypeArgumentsOrHeritageTypeReference(nodeIn) {
     let node = nodeIn;
-    while (node.parent.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+    while (node.parent.kind === 213 /* SyntaxKind.PropertyAccessExpression */ || node.parent.kind === 168 /* SyntaxKind.QualifiedName */)
         node = node.parent;
-    return node.parent.kind === 234 /* SyntaxKind.ExpressionWithTypeArguments */;
+    return node.parent.kind === 235 /* SyntaxKind.ExpressionWithTypeArguments */ || isNameOfHeritageClauseTypeReference(node);
 }
 export function isRightSideOfQualifiedNameOrPropertyAccess(node) {
     const parent = node.parent;
     switch (parent.kind) {
-        case 167 /* SyntaxKind.QualifiedName */:
+        case 168 /* SyntaxKind.QualifiedName */:
             return parent.right === node;
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
             return parent.name === node;
-        case 237 /* SyntaxKind.MetaProperty */:
+        case 238 /* SyntaxKind.MetaProperty */:
             return parent.name === node;
     }
     return false;
@@ -688,18 +691,18 @@ function isRightSideOfAccessExpression(node) {
     const parent = node.parent;
     if (parent === undefined)
         return false;
-    if (parent.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+    if (parent.kind === 213 /* SyntaxKind.PropertyAccessExpression */)
         return parent.name === node;
-    if (parent.kind === 213 /* SyntaxKind.ElementAccessExpression */)
+    if (parent.kind === 214 /* SyntaxKind.ElementAccessExpression */)
         return parent.argumentExpression === node;
     return false;
 }
 function isJsxTagName(node) {
     const parent = node.parent;
     switch (parent.kind) {
-        case 287 /* SyntaxKind.JsxOpeningElement */:
-        case 288 /* SyntaxKind.JsxClosingElement */:
-        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+        case 288 /* SyntaxKind.JsxOpeningElement */:
+        case 289 /* SyntaxKind.JsxClosingElement */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
             return getTagName(parent) === node;
     }
     return false;
@@ -708,16 +711,21 @@ export function isJSDocNameReferenceContext(node) {
     if ((node.flags & 4194304 /* NodeFlags.JSDoc */) === 0)
         return false;
     for (let current = node; current !== undefined; current = current.parent)
-        if (current.kind === 309 /* SyntaxKind.JSDocNameReference */ || isJSDocLinkLike(current))
+        if (current.kind === 310 /* SyntaxKind.JSDocNameReference */ || isJSDocLinkLike(current))
             return true;
     return false;
 }
 /** The class of an expression with type arguments in its heritage clause. */
 function getClassOfHeritageExpression(node) {
-    if (node.kind !== 234 /* SyntaxKind.ExpressionWithTypeArguments */)
+    return node.kind === 235 /* SyntaxKind.ExpressionWithTypeArguments */ ? getClassOfHeritageElement(node) : undefined;
+}
+/** The class of a heritage clause element: an expression with type arguments, or a type reference in
+ * `implements`. */
+function getClassOfHeritageElement(node) {
+    if (node.kind !== 235 /* SyntaxKind.ExpressionWithTypeArguments */ && node.kind !== 185 /* SyntaxKind.TypeReference */)
         return undefined;
     const parent = node.parent;
-    return parent.kind === 299 /* SyntaxKind.HeritageClause */ && isClassLike(parent.parent) ? parent.parent : undefined;
+    return parent.kind === 300 /* SyntaxKind.HeritageClause */ && isClassLike(parent.parent) ? parent.parent : undefined;
 }
 function isImplementsExpression(node) {
     return node.parent.token === 118 /* SyntaxKind.ImplementsKeyword */;
@@ -731,13 +739,13 @@ function isTypeDeclarationName(name) {
 /** Whether a type reference names `node`, as `T`, `N.T` or the namespace part of one. */
 function isTypeReferenceIdentifier(nodeIn) {
     let node = nodeIn;
-    while (node.parent.kind === 167 /* SyntaxKind.QualifiedName */)
+    while (node.parent.kind === 168 /* SyntaxKind.QualifiedName */)
         node = node.parent;
-    return node.parent.kind === 184 /* SyntaxKind.TypeReference */;
+    return node.parent.kind === 185 /* SyntaxKind.TypeReference */;
 }
 export function isPartOfTypeNode(node) {
     const kind = node.kind;
-    if (kind >= 183 /* SyntaxKind.FirstTypeNode */ && kind <= 206 /* SyntaxKind.LastTypeNode */)
+    if (kind >= 184 /* SyntaxKind.FirstTypeNode */ && kind <= 207 /* SyntaxKind.LastTypeNode */)
         return true;
     switch (kind) {
         case 132 /* SyntaxKind.AnyKeyword */:
@@ -753,21 +761,21 @@ export function isPartOfTypeNode(node) {
         case 146 /* SyntaxKind.NeverKeyword */:
             return true;
         case 115 /* SyntaxKind.VoidKeyword */:
-            return node.parent.kind !== 223 /* SyntaxKind.VoidExpression */;
-        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+            return node.parent.kind !== 224 /* SyntaxKind.VoidExpression */;
+        case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
             return isPartOfTypeExpressionWithTypeArguments(node);
-        case 169 /* SyntaxKind.TypeParameter */:
-            return node.parent.kind === 201 /* SyntaxKind.MappedType */ || node.parent.kind === 196 /* SyntaxKind.InferType */;
+        case 170 /* SyntaxKind.TypeParameter */:
+            return node.parent.kind === 202 /* SyntaxKind.MappedType */ || node.parent.kind === 197 /* SyntaxKind.InferType */;
         case 79 /* SyntaxKind.Identifier */: {
             const parent = node.parent;
-            if (parent.kind === 167 /* SyntaxKind.QualifiedName */ && parent.right === node)
+            if (parent.kind === 168 /* SyntaxKind.QualifiedName */ && parent.right === node)
                 return isPartOfTypeNodeInParent(parent);
-            if (parent.kind === 212 /* SyntaxKind.PropertyAccessExpression */ && parent.name === node)
+            if (parent.kind === 213 /* SyntaxKind.PropertyAccessExpression */ && parent.name === node)
                 return isPartOfTypeNodeInParent(parent);
             return isPartOfTypeNodeInParent(node);
         }
-        case 167 /* SyntaxKind.QualifiedName */:
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 168 /* SyntaxKind.QualifiedName */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
         case 109 /* SyntaxKind.ThisKeyword */:
             return isPartOfTypeNodeInParent(node);
     }
@@ -775,45 +783,45 @@ export function isPartOfTypeNode(node) {
 }
 function isPartOfTypeExpressionWithTypeArguments(node) {
     const parent = node.parent;
-    return ((parent.kind === 299 /* SyntaxKind.HeritageClause */ &&
+    return ((parent.kind === 300 /* SyntaxKind.HeritageClause */ &&
         (!isClassLike(parent.parent) || parent.token === 118 /* SyntaxKind.ImplementsKeyword */)) ||
-        parent.kind === 324 /* SyntaxKind.JSDocImplementsTag */ ||
-        parent.kind === 323 /* SyntaxKind.JSDocAugmentsTag */);
+        parent.kind === 325 /* SyntaxKind.JSDocImplementsTag */ ||
+        parent.kind === 324 /* SyntaxKind.JSDocAugmentsTag */);
 }
 // Only the parent is tested: in `let a: A.B.C`, `C` and `A.B.C` are type nodes but `A.B` isn't.
 function isPartOfTypeNodeInParent(node) {
     const parent = node.parent;
-    if (parent.kind === 187 /* SyntaxKind.TypeQuery */)
+    if (parent.kind === 188 /* SyntaxKind.TypeQuery */)
         return false;
-    if (parent.kind === 206 /* SyntaxKind.ImportType */)
+    if (parent.kind === 207 /* SyntaxKind.ImportType */)
         return !parent.isTypeOf;
-    if (parent.kind >= 183 /* SyntaxKind.FirstTypeNode */ && parent.kind <= 206 /* SyntaxKind.LastTypeNode */)
+    if (parent.kind >= 184 /* SyntaxKind.FirstTypeNode */ && parent.kind <= 207 /* SyntaxKind.LastTypeNode */)
         return true;
     switch (parent.kind) {
-        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+        case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
             return isPartOfTypeExpressionWithTypeArguments(parent);
-        case 169 /* SyntaxKind.TypeParameter */:
+        case 170 /* SyntaxKind.TypeParameter */:
             return node === parent.constraint;
-        case 261 /* SyntaxKind.VariableDeclaration */:
-        case 170 /* SyntaxKind.Parameter */:
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 172 /* SyntaxKind.PropertySignature */:
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
-        case 177 /* SyntaxKind.Constructor */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 174 /* SyntaxKind.MethodSignature */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 180 /* SyntaxKind.CallSignature */:
-        case 181 /* SyntaxKind.ConstructSignature */:
-        case 182 /* SyntaxKind.IndexSignature */:
-        case 217 /* SyntaxKind.TypeAssertionExpression */:
+        case 262 /* SyntaxKind.VariableDeclaration */:
+        case 171 /* SyntaxKind.Parameter */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 175 /* SyntaxKind.MethodSignature */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 181 /* SyntaxKind.CallSignature */:
+        case 182 /* SyntaxKind.ConstructSignature */:
+        case 183 /* SyntaxKind.IndexSignature */:
+        case 218 /* SyntaxKind.TypeAssertionExpression */:
             return node === getType(parent);
-        case 214 /* SyntaxKind.CallExpression */:
-        case 215 /* SyntaxKind.NewExpression */:
-        case 216 /* SyntaxKind.TaggedTemplateExpression */: {
+        case 215 /* SyntaxKind.CallExpression */:
+        case 216 /* SyntaxKind.NewExpression */:
+        case 217 /* SyntaxKind.TaggedTemplateExpression */: {
             const typeArguments = getTypeArguments(parent);
             return typeArguments !== undefined && typeArguments.nodes.includes(node);
         }
@@ -828,49 +836,49 @@ export function isExpressionNode(nodeIn) {
         case 111 /* SyntaxKind.TrueKeyword */:
         case 96 /* SyntaxKind.FalseKeyword */:
         case 13 /* SyntaxKind.RegularExpressionLiteral */:
-        case 210 /* SyntaxKind.ArrayLiteralExpression */:
-        case 211 /* SyntaxKind.ObjectLiteralExpression */:
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-        case 213 /* SyntaxKind.ElementAccessExpression */:
-        case 214 /* SyntaxKind.CallExpression */:
-        case 215 /* SyntaxKind.NewExpression */:
-        case 216 /* SyntaxKind.TaggedTemplateExpression */:
-        case 235 /* SyntaxKind.AsExpression */:
-        case 217 /* SyntaxKind.TypeAssertionExpression */:
-        case 239 /* SyntaxKind.SatisfiesExpression */:
-        case 236 /* SyntaxKind.NonNullExpression */:
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 232 /* SyntaxKind.ClassExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
-        case 223 /* SyntaxKind.VoidExpression */:
-        case 221 /* SyntaxKind.DeleteExpression */:
-        case 222 /* SyntaxKind.TypeOfExpression */:
-        case 225 /* SyntaxKind.PrefixUnaryExpression */:
-        case 226 /* SyntaxKind.PostfixUnaryExpression */:
-        case 227 /* SyntaxKind.BinaryExpression */:
-        case 228 /* SyntaxKind.ConditionalExpression */:
-        case 231 /* SyntaxKind.SpreadElement */:
-        case 229 /* SyntaxKind.TemplateExpression */:
-        case 233 /* SyntaxKind.OmittedExpression */:
-        case 285 /* SyntaxKind.JsxElement */:
-        case 286 /* SyntaxKind.JsxSelfClosingElement */:
-        case 289 /* SyntaxKind.JsxFragment */:
-        case 230 /* SyntaxKind.YieldExpression */:
-        case 224 /* SyntaxKind.AwaitExpression */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
+        case 216 /* SyntaxKind.NewExpression */:
+        case 217 /* SyntaxKind.TaggedTemplateExpression */:
+        case 236 /* SyntaxKind.AsExpression */:
+        case 218 /* SyntaxKind.TypeAssertionExpression */:
+        case 240 /* SyntaxKind.SatisfiesExpression */:
+        case 237 /* SyntaxKind.NonNullExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 233 /* SyntaxKind.ClassExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 224 /* SyntaxKind.VoidExpression */:
+        case 222 /* SyntaxKind.DeleteExpression */:
+        case 223 /* SyntaxKind.TypeOfExpression */:
+        case 226 /* SyntaxKind.PrefixUnaryExpression */:
+        case 227 /* SyntaxKind.PostfixUnaryExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
+        case 229 /* SyntaxKind.ConditionalExpression */:
+        case 232 /* SyntaxKind.SpreadElement */:
+        case 230 /* SyntaxKind.TemplateExpression */:
+        case 234 /* SyntaxKind.OmittedExpression */:
+        case 286 /* SyntaxKind.JsxElement */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
+        case 290 /* SyntaxKind.JsxFragment */:
+        case 231 /* SyntaxKind.YieldExpression */:
+        case 225 /* SyntaxKind.AwaitExpression */:
             return true;
-        case 237 /* SyntaxKind.MetaProperty */:
+        case 238 /* SyntaxKind.MetaProperty */:
             // `import.defer` in `import.defer(...)` isn't an expression.
             return !isImportCall(node.parent) || getExpression(node.parent) !== node;
-        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
-            return node.parent.kind !== 299 /* SyntaxKind.HeritageClause */;
-        case 167 /* SyntaxKind.QualifiedName */:
-            while (node.parent.kind === 167 /* SyntaxKind.QualifiedName */)
+        case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
+            return node.parent.kind !== 300 /* SyntaxKind.HeritageClause */;
+        case 168 /* SyntaxKind.QualifiedName */:
+            while (node.parent.kind === 168 /* SyntaxKind.QualifiedName */)
                 node = node.parent;
             return isNameReferenceParent(node) || isJsxTagName(node);
         case 80 /* SyntaxKind.PrivateIdentifier */: {
             const parent = node.parent;
-            return (parent.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+            return (parent.kind === 228 /* SyntaxKind.BinaryExpression */ &&
                 parent.left === node &&
                 parent.operatorToken.kind === 102 /* SyntaxKind.InKeyword */);
         }
@@ -890,55 +898,59 @@ export function isExpressionNode(nodeIn) {
 /** Whether `node`'s parent is a `typeof` query, a JSDoc link or a JSDoc name reference. */
 function isNameReferenceParent(node) {
     const parent = node.parent;
-    return (parent.kind === 187 /* SyntaxKind.TypeQuery */ || isJSDocLinkLike(parent) || parent.kind === 309 /* SyntaxKind.JSDocNameReference */);
+    return (parent.kind === 188 /* SyntaxKind.TypeQuery */ || isJSDocLinkLike(parent) || parent.kind === 310 /* SyntaxKind.JSDocNameReference */);
 }
 function isInExpressionContext(node) {
     const parent = node.parent;
     switch (parent.kind) {
-        case 261 /* SyntaxKind.VariableDeclaration */:
-        case 170 /* SyntaxKind.Parameter */:
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 172 /* SyntaxKind.PropertySignature */:
-        case 306 /* SyntaxKind.EnumMember */:
-        case 303 /* SyntaxKind.PropertyAssignment */:
-        case 209 /* SyntaxKind.BindingElement */:
+        case 262 /* SyntaxKind.VariableDeclaration */:
+        case 171 /* SyntaxKind.Parameter */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 307 /* SyntaxKind.EnumMember */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
+        case 210 /* SyntaxKind.BindingElement */:
             return getInitializer(parent) === node;
-        case 245 /* SyntaxKind.ExpressionStatement */:
-        case 246 /* SyntaxKind.IfStatement */:
-        case 247 /* SyntaxKind.DoStatement */:
-        case 248 /* SyntaxKind.WhileStatement */:
-        case 254 /* SyntaxKind.ReturnStatement */:
-        case 255 /* SyntaxKind.WithStatement */:
-        case 256 /* SyntaxKind.SwitchStatement */:
-        case 297 /* SyntaxKind.CaseClause */:
-        case 298 /* SyntaxKind.DefaultClause */:
-        case 258 /* SyntaxKind.ThrowStatement */:
-        case 217 /* SyntaxKind.TypeAssertionExpression */:
-        case 235 /* SyntaxKind.AsExpression */:
-        case 240 /* SyntaxKind.TemplateSpan */:
-        case 168 /* SyntaxKind.ComputedPropertyName */:
-        case 239 /* SyntaxKind.SatisfiesExpression */:
+        case 246 /* SyntaxKind.ExpressionStatement */:
+        case 247 /* SyntaxKind.IfStatement */:
+        case 248 /* SyntaxKind.DoStatement */:
+        case 249 /* SyntaxKind.WhileStatement */:
+        case 255 /* SyntaxKind.ReturnStatement */:
+        case 256 /* SyntaxKind.WithStatement */:
+        case 257 /* SyntaxKind.SwitchStatement */:
+        case 298 /* SyntaxKind.CaseClause */:
+        case 299 /* SyntaxKind.DefaultClause */:
+        case 259 /* SyntaxKind.ThrowStatement */:
+        case 218 /* SyntaxKind.TypeAssertionExpression */:
+        case 236 /* SyntaxKind.AsExpression */:
+        case 241 /* SyntaxKind.TemplateSpan */:
+        case 169 /* SyntaxKind.ComputedPropertyName */:
+        case 240 /* SyntaxKind.SatisfiesExpression */:
             return getExpression(parent) === node;
-        case 249 /* SyntaxKind.ForStatement */: {
+        case 250 /* SyntaxKind.ForStatement */: {
             const s = parent;
-            return ((s.initializer === node && node.kind !== 262 /* SyntaxKind.VariableDeclarationList */) ||
+            return ((s.initializer === node && node.kind !== 263 /* SyntaxKind.VariableDeclarationList */) ||
                 s.condition === node ||
                 s.incrementor === node);
         }
-        case 250 /* SyntaxKind.ForInStatement */:
-        case 251 /* SyntaxKind.ForOfStatement */: {
+        case 251 /* SyntaxKind.ForInStatement */:
+        case 252 /* SyntaxKind.ForOfStatement */: {
             const s = parent;
-            return (s.initializer === node && node.kind !== 262 /* SyntaxKind.VariableDeclarationList */) || s.expression === node;
+            return (s.initializer === node && node.kind !== 263 /* SyntaxKind.VariableDeclarationList */) || s.expression === node;
         }
-        case 171 /* SyntaxKind.Decorator */:
-        case 295 /* SyntaxKind.JsxExpression */:
-        case 294 /* SyntaxKind.JsxSpreadAttribute */:
-        case 305 /* SyntaxKind.SpreadAssignment */:
+        case 172 /* SyntaxKind.Decorator */:
+        case 296 /* SyntaxKind.JsxExpression */:
+        case 295 /* SyntaxKind.JsxSpreadAttribute */:
+        case 306 /* SyntaxKind.SpreadAssignment */:
             return true;
-        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+        case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
             return getExpression(parent) === node && !isPartOfTypeNode(parent);
-        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
             return parent.objectAssignmentInitializer === node;
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 233 /* SyntaxKind.ClassExpression */:
+            // The name of a function or class expression is a declaration name, not an expression.
+            return getName(parent) !== node;
     }
     return isExpressionNode(parent);
 }
@@ -950,27 +962,27 @@ function accessKind(node) {
     if (parent === undefined)
         return 0 /* AccessKind.Read */;
     switch (parent.kind) {
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
-        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
             return accessKind(parent);
-        case 225 /* SyntaxKind.PrefixUnaryExpression */:
-        case 226 /* SyntaxKind.PostfixUnaryExpression */: {
-            const operator = parent.kind === 225 /* SyntaxKind.PrefixUnaryExpression */
+        case 226 /* SyntaxKind.PrefixUnaryExpression */:
+        case 227 /* SyntaxKind.PostfixUnaryExpression */: {
+            const operator = parent.kind === 226 /* SyntaxKind.PrefixUnaryExpression */
                 ? parent.operator
                 : parent.operator;
             return operator === 45 /* SyntaxKind.PlusPlusToken */ || operator === 46 /* SyntaxKind.MinusMinusToken */
                 ? 2 /* AccessKind.ReadWrite */
                 : 0 /* AccessKind.Read */;
         }
-        case 227 /* SyntaxKind.BinaryExpression */: {
+        case 228 /* SyntaxKind.BinaryExpression */: {
             const binary = parent;
             if (binary.left === node && isAssignmentOperator(binary.operatorToken.kind))
                 return binary.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ ? 1 /* AccessKind.Write */ : 2 /* AccessKind.ReadWrite */;
             return 0 /* AccessKind.Read */;
         }
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
             return parent.name !== node ? 0 /* AccessKind.Read */ : accessKind(parent);
-        case 303 /* SyntaxKind.PropertyAssignment */: {
+        case 304 /* SyntaxKind.PropertyAssignment */: {
             const parentAccess = accessKind(parent.parent);
             // In `({ x: v } = o)`, the `x` is read and `v` written.
             if (node === getName(parent)) {
@@ -982,13 +994,13 @@ function accessKind(node) {
             }
             return parentAccess;
         }
-        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
             // The local variable is what's accessed.
             if (node === parent.objectAssignmentInitializer)
                 return 0 /* AccessKind.Read */;
             return accessKind(parent.parent);
-        case 250 /* SyntaxKind.ForInStatement */:
-        case 251 /* SyntaxKind.ForOfStatement */:
+        case 251 /* SyntaxKind.ForInStatement */:
+        case 252 /* SyntaxKind.ForOfStatement */:
             return node === parent.initializer ? 1 /* AccessKind.Write */ : 0 /* AccessKind.Read */;
     }
     return 0 /* AccessKind.Read */;