tsc-ts 0.0.10 → 0.1.0

package/dist/api/compiler/transformers/alias-references.js

@@ -3,11 +3,12 @@
 // to, except where a property access of a const enum (or an enum member in an enum
 // initializer) is inlined. Without types, a property access through anything but an alias of a
 // namespace, enum or module counts as a use.
-import { BinaryExpression, ConditionalTypeNode, ExportAssignment, ExportDeclaration, ExportSpecifier, ForInOrOfStatement, ForStatement, HeritageClause, Identifier, ImportEqualsDeclaration, ImportTypeNode, LiteralTypeNode, MetaProperty, NodeVisitor, PropertyAccessExpression, QualifiedName, ShorthandPropertyAssignment, TypeParameterDeclaration, TypeReferenceNode, VariableDeclarationList, IntersectionTypeNode, UnionTypeNode, getDotDotDotToken, getExpression, getInitializer, getParameters, getTagName, getType, getTypeArguments, } from '../ast.js';
+import { BinaryExpression, ComputedPropertyName, ConditionalTypeNode, ExportAssignment, ExportDeclaration, ExportSpecifier, ForInOrOfStatement, ForStatement, HeritageClause, Identifier, ImportEqualsDeclaration, ImportTypeNode, LiteralTypeNode, MetaProperty, NodeVisitor, PropertyAccessExpression, QualifiedName, ShorthandPropertyAssignment, TypeParameterDeclaration, TypeReferenceNode, VariableDeclarationList, IntersectionTypeNode, UnionTypeNode, getDotDotDotToken, getExpression, getHeritageClauses, getInitializer, getName, getParameters, getTagName, getType, getTypeArguments, } from '../ast.js';
 import { canHaveDecorators, isImportCall } from '../ast-utilities.js';
+import { isAssignmentTarget, isClassLike } from '../binder-utilities.js';
 import { JsxEmit, getIsolatedModules, getStrictOptionValue, shouldPreserveConstEnums, } from '../options.js';
 import { getDeclarationOfAliasSymbol } from './reference-resolver.js';
-import { getFirstConstructorWithBody, getRestParameterElementType, getSetAccessorValueParameter, nodeCanBeDecorated, } from './decorator-utilities.js';
+import { getFirstConstructorWithBody, getRestParameterElementType, getSetAccessorValueParameter, isAccessor, nodeCanBeDecorated, } from './decorator-utilities.js';
 import { hasDecorators, hasSyntacticModifier } from './utilities.js';
 import { getDeclarations } from '../symbol.js';
 export class AliasReferences extends NodeVisitor {
@@ -36,7 +37,7 @@ export class AliasReferences extends NodeVisitor {
         // Imports are marked by their uses.
         if (node instanceof ImportEqualsDeclaration && !hasSyntacticModifier(node, 32 /* ModifierFlags.Export */))
             return false;
-        if (node.kind === 273 /* SyntaxKind.ImportDeclaration */ || node.kind === 346 /* SyntaxKind.JSImportDeclaration */)
+        if (node.kind === 274 /* SyntaxKind.ImportDeclaration */ || node.kind === 347 /* SyntaxKind.JSImportDeclaration */)
             return false;
         this.mark(node);
         node.forEachChild(this);
@@ -45,15 +46,20 @@ export class AliasReferences extends NodeVisitor {
     mark(node) {
         // Types and declaration files don't use imports, except decorated properties.
         if ((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0 &&
-            node.kind !== 172 /* SyntaxKind.PropertySignature */ &&
-            node.kind !== 173 /* SyntaxKind.PropertyDeclaration */)
+            node.kind !== 173 /* SyntaxKind.PropertySignature */ &&
+            node.kind !== 174 /* SyntaxKind.PropertyDeclaration */)
+            return false;
+        // tsgo doesn't answer semantic questions inside a `with` statement.
+        if ((node.flags & 16777216 /* NodeFlags.InWithStatement */) !== 0)
             return false;
         if (node instanceof Identifier) {
             const parent = node.parent;
             if (parent === undefined ||
-                !(isExpressionNode(node) ||
-                    parent instanceof ShorthandPropertyAssignment ||
-                    (parent instanceof ImportEqualsDeclaration && parent.moduleReference === node)) ||
+                isUnresolvedIdentifier(node, this.options.experimentalDecorators === true))
+                return false;
+            if (!(isExpressionNode(node) ||
+                parent instanceof ShorthandPropertyAssignment ||
+                (parent instanceof ImportEqualsDeclaration && parent.moduleReference === node)) ||
                 !shouldMarkIdentifier(node))
                 return false;
             // Only the left of a property access or qualified name; the right is a property lookup.
@@ -61,13 +67,13 @@ export class AliasReferences extends NodeVisitor {
                 return false;
             if (parent instanceof QualifiedName && parent.left !== node)
                 return false;
-            if (isInsideMetaProperty(node))
-                return false;
             return this.markIdentifier(node);
         }
-        if (node.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || node.kind === 167 /* SyntaxKind.QualifiedName */) {
+        if (node.kind === 213 /* SyntaxKind.PropertyAccessExpression */ || node.kind === 168 /* SyntaxKind.QualifiedName */) {
             for (let top = node; top !== undefined && isPropertyAccessOrQualifiedName(top); top = top.parent)
-                if (isPartOfTypeNode(top))
+                // Names in an import type's qualifier, `ns.y` in `typeof import("./b").ns.y`, are exports of the
+                // imported module, not references to this file's imports.
+                if (isPartOfTypeNode(top) || isImportTypeQualifierPart(top))
                     return false;
             return this.markProperty(node);
         }
@@ -81,9 +87,9 @@ export class AliasReferences extends NodeVisitor {
             return true;
         }
         switch (node.kind) {
-            case 287 /* SyntaxKind.JsxOpeningElement */:
-            case 286 /* SyntaxKind.JsxSelfClosingElement */:
-            case 290 /* SyntaxKind.JsxOpeningFragment */:
+            case 288 /* SyntaxKind.JsxOpeningElement */:
+            case 287 /* SyntaxKind.JsxSelfClosingElement */:
+            case 291 /* SyntaxKind.JsxOpeningFragment */:
                 return this.markJsx(node);
         }
         if (node instanceof ImportEqualsDeclaration) {
@@ -103,14 +109,14 @@ export class AliasReferences extends NodeVisitor {
     /** Type references that decorator metadata serializes as values use the aliases they name. */
     markDecoratorMetadata(node) {
         switch (node.kind) {
-            case 264 /* SyntaxKind.ClassDeclaration */: {
+            case 265 /* SyntaxKind.ClassDeclaration */: {
                 const constructor = getFirstConstructorWithBody(node);
                 if (constructor !== undefined)
                     this.markParameterTypes(constructor);
                 break;
             }
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */: {
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */: {
                 let annotation = getAnnotatedAccessorTypeNode(node);
                 if (annotation === undefined) {
                     const other = this.getOtherAccessor(node);
@@ -120,14 +126,14 @@ export class AliasReferences extends NodeVisitor {
                 this.markMetadataTypeNode(annotation);
                 break;
             }
-            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
                 this.markParameterTypes(node);
                 this.markMetadataTypeNode(getType(node));
                 break;
-            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
                 this.markMetadataTypeNode(getType(node));
                 break;
-            case 170 /* SyntaxKind.Parameter */:
+            case 171 /* SyntaxKind.Parameter */:
                 this.markMetadataTypeNode(getParameterTypeNodeForDecoratorCheck(node));
                 if (node.parent !== undefined) {
                     this.markParameterTypes(node.parent);
@@ -149,7 +155,7 @@ export class AliasReferences extends NodeVisitor {
         const symbol = this.resolver.getSymbolOfDeclaration(node);
         if (symbol === undefined)
             return undefined;
-        const kind = node.kind === 179 /* SyntaxKind.SetAccessor */ ? 178 /* SyntaxKind.GetAccessor */ : 179 /* SyntaxKind.SetAccessor */;
+        const kind = node.kind === 180 /* SyntaxKind.SetAccessor */ ? 179 /* SyntaxKind.GetAccessor */ : 180 /* SyntaxKind.SetAccessor */;
         for (const declaration of getDeclarations(symbol))
             if (declaration.kind === kind)
                 return declaration;
@@ -176,17 +182,17 @@ export class AliasReferences extends NodeVisitor {
         if (node === undefined)
             return undefined;
         switch (node.kind) {
-            case 194 /* SyntaxKind.IntersectionType */:
-            case 193 /* SyntaxKind.UnionType */:
+            case 195 /* SyntaxKind.IntersectionType */:
+            case 194 /* SyntaxKind.UnionType */:
                 return this.getEntityNameForDecoratorMetadataFromTypeList(getTypes(node));
-            case 195 /* SyntaxKind.ConditionalType */:
+            case 196 /* SyntaxKind.ConditionalType */:
                 if (node instanceof ConditionalTypeNode)
                     return this.getEntityNameForDecoratorMetadataFromTypeList([node.trueType, node.falseType]);
                 break;
-            case 197 /* SyntaxKind.ParenthesizedType */:
-            case 203 /* SyntaxKind.NamedTupleMember */:
+            case 198 /* SyntaxKind.ParenthesizedType */:
+            case 204 /* SyntaxKind.NamedTupleMember */:
                 return this.getEntityNameForDecoratorMetadata(getType(node));
-            case 184 /* SyntaxKind.TypeReference */:
+            case 185 /* SyntaxKind.TypeReference */:
                 if (node instanceof TypeReferenceNode)
                     return node.typeName;
                 break;
@@ -244,7 +250,7 @@ export class AliasReferences extends NodeVisitor {
         this.referenced.add(symbol);
         const declaration = getDeclarationOfAliasSymbol(symbol);
         if (declaration instanceof ImportEqualsDeclaration &&
-            declaration.moduleReference.kind !== 284 /* SyntaxKind.ExternalModuleReference */) {
+            declaration.moduleReference.kind !== 285 /* SyntaxKind.ExternalModuleReference */) {
             const target = this.resolver.resolveAlias(symbol);
             const flags = target === undefined ? 4 /* SymbolFlags.Property */ : this.resolver.getSymbolFlags(target, false, false);
             if ((flags & 111551 /* SymbolFlags.Value */) !== 0)
@@ -271,7 +277,7 @@ export class AliasReferences extends NodeVisitor {
             (isConstEnumOrConstEnumOnlyModule(property) ||
                 ((property.flags & 8 /* SymbolFlags.EnumMember */) !== 0 &&
                     node.parent !== undefined &&
-                    node.parent.kind === 306 /* SyntaxKind.EnumMember */)))
+                    node.parent.kind === 307 /* SyntaxKind.EnumMember */)))
             return false;
         return this.markAlias(parentSymbol, node);
     }
@@ -288,7 +294,7 @@ export class AliasReferences extends NodeVisitor {
     markJsx(node) {
         if (this.jsxRuntimeResolved)
             return false;
-        const fragment = node.kind === 290 /* SyntaxKind.JsxOpeningFragment */;
+        const fragment = node.kind === 291 /* SyntaxKind.JsxOpeningFragment */;
         const location = fragment ? node : jsxTagName(node);
         const namespace = fragment ? this.jsxFragmentNamespace : this.jsxNamespace;
         // `@jsxFrag null` has no fragment factory.
@@ -337,8 +343,18 @@ export class AliasReferences extends NodeVisitor {
         return true;
     }
 }
+/** Whether `node` is the qualifier of an import type, or a part of one. */
+function isImportTypeQualifierPart(node) {
+    let current = node;
+    let parent = current.parent;
+    while (parent !== undefined && parent.kind === 168 /* SyntaxKind.QualifiedName */) {
+        current = parent;
+        parent = parent.parent;
+    }
+    return parent instanceof ImportTypeNode && parent.qualifier === current;
+}
 function isPropertyAccessOrQualifiedName(node) {
-    return node.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || node.kind === 167 /* SyntaxKind.QualifiedName */;
+    return node.kind === 213 /* SyntaxKind.PropertyAccessExpression */ || node.kind === 168 /* SyntaxKind.QualifiedName */;
 }
 function leftOf(node) {
     if (node instanceof PropertyAccessExpression)
@@ -372,17 +388,105 @@ function shouldMarkIdentifier(node) {
     const exportDeclaration = grandparent === undefined ? undefined : grandparent.parent;
     return !(exportDeclaration instanceof ExportDeclaration && exportDeclaration.isTypeOnly);
 }
-function isInsideMetaProperty(node) {
-    for (let current = node; current !== undefined; current = current.parent)
+/**
+ * Whether checking never resolves identifier `node`, so tsgo doesn't mark it: in a meta property, the name of a
+ * shorthand property with an initializer outside a destructuring assignment, in a decorator of a node that can't be
+ * decorated, in the expression of `for (var of x)`, in an invalid computed property name, in an interface's heritage
+ * clause, or in a class's `extends` types after the first.
+ */
+function isUnresolvedIdentifier(node, legacyDecorators) {
+    const parent = node.parent;
+    if (parent instanceof ShorthandPropertyAssignment &&
+        parent.name === node &&
+        parent.objectAssignmentInitializer !== undefined &&
+        !isAssignmentTarget(parent.parent))
+        return true;
+    let decorator = undefined;
+    let forNode = undefined;
+    let computedName = undefined;
+    let heritageClause = undefined;
+    for (let current = node; current !== undefined; current = current.parent) {
         if (current instanceof MetaProperty)
             return true;
+        if (current.kind === 172 /* SyntaxKind.Decorator */) {
+            if (decorator === undefined)
+                decorator = current;
+        }
+        else if (current instanceof ForInOrOfStatement) {
+            if (forNode === undefined)
+                forNode = current;
+        }
+        else if (current instanceof ComputedPropertyName) {
+            if (computedName === undefined)
+                computedName = current;
+        }
+        else if (current instanceof HeritageClause) {
+            if (heritageClause === undefined)
+                heritageClause = current;
+        }
+    }
+    if (decorator !== undefined) {
+        const decorated = decorator.parent;
+        if (decorated !== undefined &&
+            !nodeCanBeDecorated(legacyDecorators, decorated, decorated.parent, decorated.parent === undefined ? undefined : decorated.parent.parent))
+            return true;
+    }
+    if (forNode !== undefined) {
+        const statement = forNode;
+        if (statement.initializer instanceof VariableDeclarationList &&
+            statement.initializer.declarations.nodes.length === 0 &&
+            (node === statement.expression || isNodeDescendantOf(node, statement.expression)))
+            return true;
+    }
+    if (computedName !== undefined) {
+        const grandparent = computedName.parent.parent;
+        if ((grandparent.kind === 189 /* SyntaxKind.TypeLiteral */ ||
+            isClassLike(grandparent) ||
+            grandparent.kind === 266 /* SyntaxKind.InterfaceDeclaration */) &&
+            computedName.expression instanceof BinaryExpression &&
+            computedName.expression.operatorToken.kind ===
+                102 /* SyntaxKind.InKeyword */ &&
+            !isAccessor(computedName.parent))
+            return true;
+    }
+    if (heritageClause !== undefined) {
+        const declaration = heritageClause.parent;
+        // An interface's heritage clauses are types.
+        if (declaration.kind === 266 /* SyntaxKind.InterfaceDeclaration */)
+            return true;
+        // Only a class's first `extends` type is its base class; checking never resolves the others.
+        if (isClassLike(declaration) && heritageClause.token === 95 /* SyntaxKind.ExtendsKeyword */) {
+            const first = getClassExtendsHeritageElement(declaration);
+            if (first !== undefined && node !== first && !isNodeDescendantOf(node, first))
+                return true;
+        }
+    }
+    return false;
+}
+/** The first type of a class's first `extends` clause. */
+function getClassExtendsHeritageElement(node) {
+    const clauses = getHeritageClauses(node);
+    if (clauses === undefined)
+        return undefined;
+    for (const clause of clauses.nodes)
+        if (clause.token === 95 /* SyntaxKind.ExtendsKeyword */) {
+            const types = clause.types.nodes;
+            return types.length > 0 ? types[0] : undefined;
+        }
+    return undefined;
+}
+/** Whether `node` is inside `ancestor`. */
+function isNodeDescendantOf(node, ancestor) {
+    for (let current = node.parent; current !== undefined; current = current.parent)
+        if (current === ancestor)
+            return true;
     return false;
 }
 function isInTypeQuery(node) {
     for (let current = node; current !== undefined; current = current.parent) {
-        if (current.kind === 187 /* SyntaxKind.TypeQuery */)
+        if (current.kind === 188 /* SyntaxKind.TypeQuery */)
             return true;
-        if (current.kind !== 79 /* SyntaxKind.Identifier */ && current.kind !== 167 /* SyntaxKind.QualifiedName */)
+        if (current.kind !== 79 /* SyntaxKind.Identifier */ && current.kind !== 168 /* SyntaxKind.QualifiedName */)
             return false;
     }
     return false;
@@ -440,49 +544,49 @@ export function isExpressionNode(node) {
         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 */: {
             const parent = node.parent;
             return !(parent !== undefined && isImportCall(parent) && getExpression(parent) === node);
         }
-        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+        case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
             return !(node.parent instanceof HeritageClause);
-        case 167 /* SyntaxKind.QualifiedName */: {
+        case 168 /* SyntaxKind.QualifiedName */: {
             let current = node;
-            while (current.parent !== undefined && current.parent.kind === 167 /* SyntaxKind.QualifiedName */)
+            while (current.parent !== undefined && current.parent.kind === 168 /* SyntaxKind.QualifiedName */)
                 current = current.parent;
             const parent = current.parent;
-            return parent !== undefined && (parent.kind === 187 /* SyntaxKind.TypeQuery */ || isJsxTagName(current));
+            return parent !== undefined && (parent.kind === 188 /* SyntaxKind.TypeQuery */ || isJsxTagName(current));
         }
         case 80 /* SyntaxKind.PrivateIdentifier */: {
             const parent = node.parent;
@@ -490,7 +594,7 @@ export function isExpressionNode(node) {
         }
         case 79 /* SyntaxKind.Identifier */: {
             const parent = node.parent;
-            if (parent !== undefined && (parent.kind === 187 /* SyntaxKind.TypeQuery */ || isJsxTagName(node)))
+            if (parent !== undefined && (parent.kind === 188 /* SyntaxKind.TypeQuery */ || isJsxTagName(node)))
                 return true;
             return isInExpressionContext(node);
         }
@@ -508,51 +612,55 @@ function isInExpressionContext(node) {
     if (parent === undefined)
         return false;
     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 */:
             if (!(parent instanceof ForStatement))
                 return false;
             return ((parent.initializer === node && !(parent.initializer instanceof VariableDeclarationList)) ||
                 parent.condition === node ||
                 parent.incrementor === node);
-        case 250 /* SyntaxKind.ForInStatement */:
-        case 251 /* SyntaxKind.ForOfStatement */:
+        case 251 /* SyntaxKind.ForInStatement */:
+        case 252 /* SyntaxKind.ForOfStatement */:
             if (!(parent instanceof ForInOrOfStatement))
                 return false;
             return ((parent.initializer === node && !(parent.initializer instanceof VariableDeclarationList)) ||
                 parent.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 instanceof ShorthandPropertyAssignment && 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);
 }
@@ -561,16 +669,16 @@ function isJsxTagName(node) {
     if (parent === undefined)
         return false;
     switch (parent.kind) {
-        case 287 /* SyntaxKind.JsxOpeningElement */:
-        case 286 /* SyntaxKind.JsxSelfClosingElement */:
-        case 288 /* SyntaxKind.JsxClosingElement */:
+        case 288 /* SyntaxKind.JsxOpeningElement */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
+        case 289 /* SyntaxKind.JsxClosingElement */:
             return getTagName(parent) === node;
     }
     return false;
 }
 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 */:
@@ -586,12 +694,12 @@ export function isPartOfTypeNode(node) {
         case 146 /* SyntaxKind.NeverKeyword */:
             return true;
         case 115 /* SyntaxKind.VoidKeyword */:
-            return node.parent !== undefined && node.parent.kind !== 223 /* SyntaxKind.VoidExpression */;
-        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+            return node.parent !== undefined && node.parent.kind !== 224 /* SyntaxKind.VoidExpression */;
+        case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
             return isPartOfTypeExpressionWithTypeArguments(node);
-        case 169 /* SyntaxKind.TypeParameter */:
+        case 170 /* SyntaxKind.TypeParameter */:
             return (node.parent !== undefined &&
-                (node.parent.kind === 201 /* SyntaxKind.MappedType */ || node.parent.kind === 196 /* SyntaxKind.InferType */));
+                (node.parent.kind === 202 /* SyntaxKind.MappedType */ || node.parent.kind === 197 /* SyntaxKind.InferType */));
         case 79 /* SyntaxKind.Identifier */: {
             const parent = node.parent;
             if (parent instanceof QualifiedName && parent.right === node)
@@ -600,8 +708,8 @@ export function isPartOfTypeNode(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);
     }
@@ -609,37 +717,37 @@ export function isPartOfTypeNode(node) {
 }
 function isPartOfTypeNodeInParent(node) {
     const parent = node.parent;
-    if (parent === undefined || parent.kind === 187 /* SyntaxKind.TypeQuery */)
+    if (parent === undefined || parent.kind === 188 /* SyntaxKind.TypeQuery */)
         return false;
     if (parent instanceof ImportTypeNode)
         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 parent instanceof TypeParameterDeclaration && parent.constraint === node;
-        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 getType(parent) === node;
-        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.indexOf(node) >= 0;
         }
@@ -651,11 +759,11 @@ function isPartOfTypeExpressionWithTypeArguments(node) {
     if (parent instanceof HeritageClause) {
         const container = parent.parent;
         const classLike = container !== undefined &&
-            (container.kind === 264 /* SyntaxKind.ClassDeclaration */ || container.kind === 232 /* SyntaxKind.ClassExpression */);
+            (container.kind === 265 /* SyntaxKind.ClassDeclaration */ || container.kind === 233 /* SyntaxKind.ClassExpression */);
         return !classLike || parent.token === 118 /* SyntaxKind.ImplementsKeyword */;
     }
     return (parent !== undefined &&
-        (parent.kind === 324 /* SyntaxKind.JSDocImplementsTag */ || parent.kind === 323 /* SyntaxKind.JSDocAugmentsTag */));
+        (parent.kind === 325 /* SyntaxKind.JSDocImplementsTag */ || parent.kind === 324 /* SyntaxKind.JSDocAugmentsTag */));
 }
 function getParameterTypeNodeForDecoratorCheck(node) {
     const type = getType(node);
@@ -663,7 +771,7 @@ function getParameterTypeNodeForDecoratorCheck(node) {
 }
 /** The type annotation of a getter, or of a setter's parameter. */
 function getAnnotatedAccessorTypeNode(node) {
-    if (node.kind === 178 /* SyntaxKind.GetAccessor */)
+    if (node.kind === 179 /* SyntaxKind.GetAccessor */)
         return getType(node);
     const parameter = getSetAccessorValueParameter(node);
     return parameter === undefined ? undefined : getType(parameter);