tsc-ts 0.0.3 → 0.0.5

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

@@ -0,0 +1,676 @@
+// Which aliases (imports and `import x = ...`) a file uses as values, found as the checker's
+// `markLinkedReferences` finds them: identifiers in expressions mark the aliases they resolve
+// 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 { canHaveDecorators, isImportCall } from '../ast-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 { hasDecorators, hasSyntacticModifier } from './utilities.js';
+export class AliasReferences extends NodeVisitor {
+    options;
+    resolver;
+    /** Alias symbols used as values. */
+    referenced;
+    jsxNamespace;
+    jsxFragmentNamespace;
+    /** Whether the JSX runtime's module resolves, so JSX doesn't use the factory's names. */
+    jsxRuntimeResolved;
+    constructor(options, resolver, jsxNamespace, jsxFragmentNamespace, jsxRuntimeResolved) {
+        super();
+        this.options = options;
+        this.resolver = resolver;
+        this.referenced = new Set();
+        this.jsxNamespace = jsxNamespace;
+        this.jsxFragmentNamespace = jsxFragmentNamespace;
+        this.jsxRuntimeResolved = jsxRuntimeResolved;
+    }
+    markFile(file) {
+        file.forEachChild(this);
+        return true;
+    }
+    visitNode(node) {
+        // 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 */)
+            return false;
+        this.mark(node);
+        node.forEachChild(this);
+        return false;
+    }
+    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 */)
+            return false;
+        if (node instanceof Identifier) {
+            const parent = node.parent;
+            if (parent === undefined ||
+                !(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.
+            if (parent instanceof PropertyAccessExpression && parent.expression !== node)
+                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 */) {
+            for (let top = node; top !== undefined && isPropertyAccessOrQualifiedName(top); top = top.parent)
+                if (isPartOfTypeNode(top))
+                    return false;
+            return this.markProperty(node);
+        }
+        if (node instanceof ExportAssignment) {
+            const expression = node.expression;
+            if (!(expression instanceof Identifier))
+                return false;
+            const symbol = this.resolver.resolveEntityName(expression, 1073741823 /* SymbolFlags.All */, true);
+            if (symbol !== undefined)
+                this.markAlias(this.resolver.getExportSymbolOfValueSymbolIfExported(symbol), expression);
+            return true;
+        }
+        switch (node.kind) {
+            case 287 /* SyntaxKind.JsxOpeningElement */:
+            case 286 /* SyntaxKind.JsxSelfClosingElement */:
+            case 290 /* SyntaxKind.JsxOpeningFragment */:
+                return this.markJsx(node);
+        }
+        if (node instanceof ImportEqualsDeclaration) {
+            if (hasSyntacticModifier(node, 32 /* ModifierFlags.Export */))
+                this.markExport(node);
+            return true;
+        }
+        if (node instanceof ExportSpecifier)
+            return this.markExportSpecifier(node);
+        if (this.options.emitDecoratorMetadata === true &&
+            canHaveDecorators(node) &&
+            hasDecorators(node) &&
+            nodeCanBeDecorated(this.options.experimentalDecorators === true, node, node.parent, node.parent === undefined ? undefined : node.parent.parent))
+            return this.markDecoratorMetadata(node);
+        return false;
+    }
+    /** Type references that decorator metadata serializes as values use the aliases they name. */
+    markDecoratorMetadata(node) {
+        switch (node.kind) {
+            case 264 /* SyntaxKind.ClassDeclaration */: {
+                const constructor = getFirstConstructorWithBody(node);
+                if (constructor !== undefined)
+                    this.markParameterTypes(constructor);
+                break;
+            }
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */: {
+                let annotation = getAnnotatedAccessorTypeNode(node);
+                if (annotation === undefined) {
+                    const other = this.getOtherAccessor(node);
+                    if (other !== undefined)
+                        annotation = getAnnotatedAccessorTypeNode(other);
+                }
+                this.markMetadataTypeNode(annotation);
+                break;
+            }
+            case 175 /* SyntaxKind.MethodDeclaration */:
+                this.markParameterTypes(node);
+                this.markMetadataTypeNode(getType(node));
+                break;
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+                this.markMetadataTypeNode(getType(node));
+                break;
+            case 170 /* SyntaxKind.Parameter */:
+                this.markMetadataTypeNode(getParameterTypeNodeForDecoratorCheck(node));
+                if (node.parent !== undefined) {
+                    this.markParameterTypes(node.parent);
+                    this.markMetadataTypeNode(getType(node.parent));
+                }
+                break;
+        }
+        return true;
+    }
+    markParameterTypes(node) {
+        const parameters = getParameters(node);
+        if (parameters === undefined)
+            return false;
+        for (let i = 0; i < parameters.nodes.length; i++)
+            this.markMetadataTypeNode(getParameterTypeNodeForDecoratorCheck(parameters.nodes[i]));
+        return true;
+    }
+    getOtherAccessor(node) {
+        const symbol = this.resolver.getSymbolOfDeclaration(node);
+        if (symbol === undefined)
+            return undefined;
+        const kind = node.kind === 179 /* SyntaxKind.SetAccessor */ ? 178 /* SyntaxKind.GetAccessor */ : 179 /* SyntaxKind.SetAccessor */;
+        for (const declaration of symbol.declarations)
+            if (declaration.kind === kind)
+                return declaration;
+        return undefined;
+    }
+    markMetadataTypeNode(node) {
+        const name = this.getEntityNameForDecoratorMetadata(node);
+        if (name === undefined || !(name instanceof Identifier || name instanceof QualifiedName))
+            return false;
+        const root = firstIdentifier(name);
+        const meaning = (name instanceof Identifier ? 788968 /* SymbolFlags.Type */ : 1920 /* SymbolFlags.Namespace */) | 2097152 /* SymbolFlags.Alias */;
+        const symbol = this.resolver.resolveName(root, root.text, meaning);
+        if (symbol === undefined || (symbol.flags & 2097152 /* SymbolFlags.Alias */) === 0)
+            return false;
+        const target = this.resolver.resolveAlias(symbol);
+        if ((this.resolver.getSymbolFlags(symbol, true, false) & 111551 /* SymbolFlags.Value */) !== 0 &&
+            (target === undefined || !isConstEnumOrConstEnumOnlyModule(target)) &&
+            !this.resolver.isTypeOnlyAliasChain(symbol))
+            this.markAliasSymbol(symbol);
+        return true;
+    }
+    /** The entity name a type serializes to, if it serializes to one: `A` of `A | null`, but nothing for `A | B`. */
+    getEntityNameForDecoratorMetadata(node) {
+        if (node === undefined)
+            return undefined;
+        switch (node.kind) {
+            case 194 /* SyntaxKind.IntersectionType */:
+            case 193 /* SyntaxKind.UnionType */:
+                return this.getEntityNameForDecoratorMetadataFromTypeList(getTypes(node));
+            case 195 /* SyntaxKind.ConditionalType */:
+                if (node instanceof ConditionalTypeNode)
+                    return this.getEntityNameForDecoratorMetadataFromTypeList([node.trueType, node.falseType]);
+                break;
+            case 197 /* SyntaxKind.ParenthesizedType */:
+            case 203 /* SyntaxKind.NamedTupleMember */:
+                return this.getEntityNameForDecoratorMetadata(getType(node));
+            case 184 /* SyntaxKind.TypeReference */:
+                if (node instanceof TypeReferenceNode)
+                    return node.typeName;
+                break;
+        }
+        return undefined;
+    }
+    getEntityNameForDecoratorMetadataFromTypeList(types) {
+        const strictNullChecks = getStrictOptionValue(this.options, this.options.strictNullChecks);
+        let common = undefined;
+        for (let i = 0; i < types.length; i++) {
+            const type = types[i];
+            if (type.kind === 146 /* SyntaxKind.NeverKeyword */)
+                continue;
+            if (!strictNullChecks &&
+                ((type instanceof LiteralTypeNode && type.literal.kind === 105 /* SyntaxKind.NullKeyword */) ||
+                    type.kind === 157 /* SyntaxKind.UndefinedKeyword */))
+                continue;
+            const name = this.getEntityNameForDecoratorMetadata(type);
+            // Something like `string`, serialized as itself or `Object`.
+            if (name === undefined)
+                return undefined;
+            if (common === undefined)
+                common = name;
+            else if (!(common instanceof Identifier) || !(name instanceof Identifier) || common.text !== name.text)
+                return undefined;
+        }
+        return common;
+    }
+    markIdentifier(node) {
+        const symbol = this.resolver.getResolvedSymbol(node);
+        if (symbol === undefined || node.text === 'arguments')
+            return false;
+        return this.markAlias(symbol, node);
+    }
+    markAlias(symbol, location) {
+        if (!isNonLocalAlias(symbol) || isInTypeQuery(location))
+            return false;
+        const target = this.resolver.resolveAlias(symbol);
+        const flags = this.resolver.getSymbolFlags(symbol, true, false);
+        if ((flags & (111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */)) === 0)
+            return false;
+        // Uses of a const enum are inlined, unless it isn't (`isolatedModules`) or the use is an export of a preserved one.
+        if (getIsolatedModules(this.options) ||
+            (shouldPreserveConstEnums(this.options) && isExportOrExportExpression(location)) ||
+            target === undefined ||
+            !isConstEnumOrConstEnumOnlyModule(this.resolver.getExportSymbolOfValueSymbolIfExported(target)))
+            this.markAliasSymbol(symbol);
+        return true;
+    }
+    /** Marks an alias used, and for `import x = a.b`, what it names. */
+    markAliasSymbol(alias) {
+        const symbol = this.resolver.getMergedSymbol(alias);
+        if (this.referenced.has(symbol))
+            return false;
+        this.referenced.add(symbol);
+        const declaration = getDeclarationOfAliasSymbol(symbol);
+        if (declaration instanceof ImportEqualsDeclaration &&
+            declaration.moduleReference.kind !== 284 /* 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)
+                this.markIdentifier(firstIdentifier(declaration.moduleReference));
+        }
+        return true;
+    }
+    /** `Foo.Bar` uses `Foo` unless `Bar` is a const enum (or a namespace of them), or an enum member inlined in an enum. */
+    markProperty(node) {
+        if (isPartOfImportEqualsModuleReference(node))
+            return false;
+        const left = leftOf(node);
+        if (!(left instanceof Identifier))
+            return false;
+        const parentSymbol = this.resolver.getResolvedSymbol(left);
+        if (parentSymbol === undefined)
+            return false;
+        if (getIsolatedModules(this.options) ||
+            (shouldPreserveConstEnums(this.options) && isExportOrExportExpression(node)))
+            return this.markAlias(parentSymbol, node);
+        const right = rightOf(node);
+        const property = right instanceof Identifier ? this.getPropertyOfAlias(parentSymbol, right.text) : undefined;
+        if (property !== undefined &&
+            (isConstEnumOrConstEnumOnlyModule(property) ||
+                ((property.flags & 8 /* SymbolFlags.EnumMember */) !== 0 &&
+                    node.parent !== undefined &&
+                    node.parent.kind === 306 /* SyntaxKind.EnumMember */)))
+            return false;
+        return this.markAlias(parentSymbol, node);
+    }
+    /** A member of the namespace, enum or module an alias names, the type of the alias without a checker. */
+    getPropertyOfAlias(symbol, name) {
+        if ((symbol.flags & 2097152 /* SymbolFlags.Alias */) === 0)
+            return undefined;
+        const target = this.resolver.resolveAlias(symbol);
+        if (target === undefined || (target.flags & (1920 /* SymbolFlags.Namespace */ | 1536 /* SymbolFlags.Module */)) === 0)
+            return undefined;
+        const member = this.resolver.getExportOfSymbol(target, name);
+        return member === undefined ? undefined : this.resolver.resolveAlias(member);
+    }
+    markJsx(node) {
+        if (this.jsxRuntimeResolved)
+            return false;
+        const fragment = node.kind === 290 /* SyntaxKind.JsxOpeningFragment */;
+        const location = fragment ? node : jsxTagName(node);
+        const namespace = fragment ? this.jsxFragmentNamespace : this.jsxNamespace;
+        // `@jsxFrag null` has no fragment factory.
+        if (fragment && namespace === 'null')
+            return false;
+        let flags = 111551 /* SymbolFlags.Value */;
+        if (this.options.jsx === JsxEmit.Preserve || this.options.jsx === JsxEmit.ReactNative)
+            flags &= ~384 /* SymbolFlags.Enum */;
+        const symbol = this.resolver.resolveName(location, namespace, flags);
+        if (symbol !== undefined &&
+            (symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0 &&
+            !this.resolver.isTypeOnlyAliasSymbol(symbol))
+            this.markAliasSymbol(symbol);
+        return true;
+    }
+    markExport(node) {
+        const symbol = this.resolver.getSymbolOfDeclaration(node);
+        if (symbol === undefined)
+            return false;
+        const target = this.resolver.resolveAlias(symbol);
+        if (target === undefined ||
+            ((this.resolver.getSymbolFlags(symbol, true, false) & 111551 /* SymbolFlags.Value */) !== 0 &&
+                !isConstEnumOrConstEnumOnlyModule(target)))
+            this.markAliasSymbol(symbol);
+        return true;
+    }
+    markExportSpecifier(node) {
+        const declaration = node.parent === undefined ? undefined : node.parent.parent;
+        if (!(declaration instanceof ExportDeclaration) ||
+            declaration.moduleSpecifier !== undefined ||
+            node.isTypeOnly ||
+            declaration.isTypeOnly)
+            return false;
+        const exported = node.propertyName !== undefined ? node.propertyName : node.name;
+        if (!(exported instanceof Identifier))
+            return false;
+        const symbol = this.resolver.resolveName(exported, exported.text, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 2097152 /* SymbolFlags.Alias */);
+        // Globals aren't imports.
+        if (symbol !== undefined && this.resolver.isGlobalSymbol(symbol))
+            return false;
+        const target = symbol !== undefined && (symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0 ? this.resolver.resolveAlias(symbol) : symbol;
+        if (target === undefined || (this.resolver.getSymbolFlags(target, false, false) & 111551 /* SymbolFlags.Value */) !== 0) {
+            this.markExport(node);
+            this.markIdentifier(exported);
+        }
+        return true;
+    }
+}
+function isPropertyAccessOrQualifiedName(node) {
+    return node.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || node.kind === 167 /* SyntaxKind.QualifiedName */;
+}
+function leftOf(node) {
+    if (node instanceof PropertyAccessExpression)
+        return node.expression;
+    if (node instanceof QualifiedName)
+        return node.left;
+    return undefined;
+}
+function rightOf(node) {
+    if (node instanceof PropertyAccessExpression)
+        return node.name;
+    if (node instanceof QualifiedName)
+        return node.right;
+    return undefined;
+}
+function isConstEnumOrConstEnumOnlyModule(symbol) {
+    return (symbol.flags & 128 /* SymbolFlags.ConstEnum */) !== 0 || (symbol.flags & 268435456 /* SymbolFlags.ConstEnumOnlyModule */) !== 0;
+}
+function isNonLocalAlias(symbol) {
+    return (symbol.flags & (2097152 /* SymbolFlags.Alias */ | 111551 /* SymbolFlags.Value */)) === 2097152 /* SymbolFlags.Alias */;
+}
+function shouldMarkIdentifier(node) {
+    const parent = node.parent;
+    // The left of a property access is marked with the access.
+    if (parent instanceof PropertyAccessExpression && parent.expression === node)
+        return false;
+    // Names in type-only exports.
+    if (parent instanceof ExportSpecifier && parent.isTypeOnly)
+        return false;
+    const grandparent = parent.parent;
+    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)
+        if (current instanceof MetaProperty)
+            return true;
+    return false;
+}
+function isInTypeQuery(node) {
+    for (let current = node; current !== undefined; current = current.parent) {
+        if (current.kind === 187 /* SyntaxKind.TypeQuery */)
+            return true;
+        if (current.kind !== 79 /* SyntaxKind.Identifier */ && current.kind !== 167 /* SyntaxKind.QualifiedName */)
+            return false;
+    }
+    return false;
+}
+function isExportOrExportExpression(location) {
+    for (let node = location; node !== undefined; node = node.parent) {
+        const parent = node.parent;
+        if (parent === undefined)
+            return false;
+        if (parent instanceof ExportAssignment && parent.expression === node && isEntityNameExpression(node))
+            return true;
+        if (parent instanceof ExportSpecifier && (parent.name === node || parent.propertyName === node))
+            return true;
+    }
+    return false;
+}
+function isEntityNameExpression(node) {
+    if (node instanceof Identifier)
+        return true;
+    return (node instanceof PropertyAccessExpression &&
+        node.name instanceof Identifier &&
+        isEntityNameExpression(node.expression));
+}
+function isPartOfImportEqualsModuleReference(node) {
+    let child = node;
+    for (let current = node.parent; current !== undefined; current = current.parent) {
+        if (current instanceof ImportEqualsDeclaration)
+            return (current.moduleReference === child ||
+                (child.pos >= current.moduleReference.pos && child.end <= current.moduleReference.end));
+        child = current;
+    }
+    return false;
+}
+function firstIdentifier(node) {
+    let current = node;
+    for (;;) {
+        if (current instanceof QualifiedName)
+            current = current.left;
+        else if (current instanceof PropertyAccessExpression)
+            current = current.expression;
+        else
+            break;
+    }
+    return current;
+}
+function jsxTagName(node) {
+    const tagName = getTagName(node);
+    return tagName !== undefined ? tagName : node;
+}
+// Expression positions, as tsgo's `IsExpressionNode` decides them.
+export function isExpressionNode(node) {
+    switch (node.kind) {
+        case 107 /* SyntaxKind.SuperKeyword */:
+        case 105 /* SyntaxKind.NullKeyword */:
+        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 */:
+            return true;
+        case 237 /* SyntaxKind.MetaProperty */: {
+            const parent = node.parent;
+            return !(parent !== undefined && isImportCall(parent) && getExpression(parent) === node);
+        }
+        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+            return !(node.parent instanceof HeritageClause);
+        case 167 /* SyntaxKind.QualifiedName */: {
+            let current = node;
+            while (current.parent !== undefined && current.parent.kind === 167 /* SyntaxKind.QualifiedName */)
+                current = current.parent;
+            const parent = current.parent;
+            return parent !== undefined && (parent.kind === 187 /* SyntaxKind.TypeQuery */ || isJsxTagName(current));
+        }
+        case 80 /* SyntaxKind.PrivateIdentifier */: {
+            const parent = node.parent;
+            return (parent instanceof BinaryExpression && parent.left === node && parent.operatorToken.kind === 102 /* SyntaxKind.InKeyword */);
+        }
+        case 79 /* SyntaxKind.Identifier */: {
+            const parent = node.parent;
+            if (parent !== undefined && (parent.kind === 187 /* SyntaxKind.TypeQuery */ || isJsxTagName(node)))
+                return true;
+            return isInExpressionContext(node);
+        }
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 9 /* SyntaxKind.BigIntLiteral */:
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+        case 109 /* SyntaxKind.ThisKeyword */:
+            return isInExpressionContext(node);
+    }
+    return false;
+}
+function isInExpressionContext(node) {
+    const parent = node.parent;
+    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 */:
+            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 */:
+            return getExpression(parent) === node;
+        case 249 /* 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 */:
+            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 */:
+            return true;
+        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+            return getExpression(parent) === node && !isPartOfTypeNode(parent);
+        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+            return parent instanceof ShorthandPropertyAssignment && parent.objectAssignmentInitializer === node;
+    }
+    return isExpressionNode(parent);
+}
+function isJsxTagName(node) {
+    const parent = node.parent;
+    if (parent === undefined)
+        return false;
+    switch (parent.kind) {
+        case 287 /* SyntaxKind.JsxOpeningElement */:
+        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+        case 288 /* 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 */)
+        return true;
+    switch (kind) {
+        case 132 /* SyntaxKind.AnyKeyword */:
+        case 159 /* SyntaxKind.UnknownKeyword */:
+        case 150 /* SyntaxKind.NumberKeyword */:
+        case 163 /* SyntaxKind.BigIntKeyword */:
+        case 154 /* SyntaxKind.StringKeyword */:
+        case 135 /* SyntaxKind.BooleanKeyword */:
+        case 155 /* SyntaxKind.SymbolKeyword */:
+        case 151 /* SyntaxKind.ObjectKeyword */:
+        case 157 /* SyntaxKind.UndefinedKeyword */:
+        case 105 /* SyntaxKind.NullKeyword */:
+        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 isPartOfTypeExpressionWithTypeArguments(node);
+        case 169 /* SyntaxKind.TypeParameter */:
+            return (node.parent !== undefined &&
+                (node.parent.kind === 201 /* SyntaxKind.MappedType */ || node.parent.kind === 196 /* SyntaxKind.InferType */));
+        case 79 /* SyntaxKind.Identifier */: {
+            const parent = node.parent;
+            if (parent instanceof QualifiedName && parent.right === node)
+                return isPartOfTypeNodeInParent(parent);
+            if (parent instanceof PropertyAccessExpression && parent.name === node)
+                return isPartOfTypeNodeInParent(parent);
+            return isPartOfTypeNodeInParent(node);
+        }
+        case 167 /* SyntaxKind.QualifiedName */:
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 109 /* SyntaxKind.ThisKeyword */:
+            return isPartOfTypeNodeInParent(node);
+    }
+    return false;
+}
+function isPartOfTypeNodeInParent(node) {
+    const parent = node.parent;
+    if (parent === undefined || parent.kind === 187 /* SyntaxKind.TypeQuery */)
+        return false;
+    if (parent instanceof ImportTypeNode)
+        return !parent.isTypeOf;
+    if (parent.kind >= 183 /* SyntaxKind.FirstTypeNode */ && parent.kind <= 206 /* SyntaxKind.LastTypeNode */)
+        return true;
+    switch (parent.kind) {
+        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+            return isPartOfTypeExpressionWithTypeArguments(parent);
+        case 169 /* 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 */:
+            return getType(parent) === node;
+        case 214 /* SyntaxKind.CallExpression */:
+        case 215 /* SyntaxKind.NewExpression */:
+        case 216 /* SyntaxKind.TaggedTemplateExpression */: {
+            const typeArguments = getTypeArguments(parent);
+            return typeArguments !== undefined && typeArguments.nodes.indexOf(node) >= 0;
+        }
+    }
+    return false;
+}
+function isPartOfTypeExpressionWithTypeArguments(node) {
+    const parent = node.parent;
+    if (parent instanceof HeritageClause) {
+        const container = parent.parent;
+        const classLike = container !== undefined &&
+            (container.kind === 264 /* SyntaxKind.ClassDeclaration */ || container.kind === 232 /* SyntaxKind.ClassExpression */);
+        return !classLike || parent.token === 118 /* SyntaxKind.ImplementsKeyword */;
+    }
+    return (parent !== undefined &&
+        (parent.kind === 324 /* SyntaxKind.JSDocImplementsTag */ || parent.kind === 323 /* SyntaxKind.JSDocAugmentsTag */));
+}
+function getParameterTypeNodeForDecoratorCheck(node) {
+    const type = getType(node);
+    return getDotDotDotToken(node) !== undefined ? getRestParameterElementType(type) : type;
+}
+/** The type annotation of a getter, or of a setter's parameter. */
+function getAnnotatedAccessorTypeNode(node) {
+    if (node.kind === 178 /* SyntaxKind.GetAccessor */)
+        return getType(node);
+    const parameter = getSetAccessorValueParameter(node);
+    return parameter === undefined ? undefined : getType(parameter);
+}
+function getTypes(node) {
+    if (node instanceof UnionTypeNode)
+        return node.types.nodes;
+    if (node instanceof IntersectionTypeNode)
+        return node.types.nodes;
+    return [];
+}