tsc-ts 0.0.4 → 0.0.6

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

@@ -0,0 +1,995 @@
+// Checker queries for language services and the API: the symbol or type at a node, constant
+// 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 { 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';
+import { computeEnumMemberValues, getBaseTypes, getDeclaredTypeOfClassOrInterface, getDeclaredTypeOfSymbol, isEntityNameExpression, } from './checker-declared-types.js';
+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 { getSymbolHasInstanceMethodOfObjectType } from './checker-operators.js';
+import { getSymbolForPrivateIdentifierExpression } from './checker-property-access.js';
+import { getSignatureFromDeclaration } from './checker-signatures.js';
+import { getAnnotatedAccessorTypeNode, getNonMissingTypeOfSymbol, getTypeForVariableLikeDeclaration, getTypeOfSymbol, getWriteTypeOfAccessors, getWriteTypeOfSymbol, removeOptionalTypeMarker, } from './checker-symbol-types.js';
+import { getCachedGlobalType, getDeclarationOfAliasSymbol, getExportsOfModule, getExportsOfSymbol, getExportSymbolOfValueSymbolIfExported, getMergedSymbol, getSymbolOfDeclaration, isReservedMemberName, resolveEntityName, } from './checker-symbols.js';
+import { createAnonymousType, getRegularTypeOfLiteralType, isErrorType } from './checker-type-factory.js';
+import { getLiteralTypeFromPropertyName } from './checker-type-operators.js';
+import { getTypeFromThisTypeNode, getTypeFromTypeNode, getUnresolvedSymbolForEntityName, } from './checker-type-nodes.js';
+import { getNodeAtPosition } from './parser.js';
+import { getSymbolId, setDeclarations } from './symbol.js';
+// ---- Symbols at locations
+/** The symbol a name, keyword or literal at `node` refers to. */
+export function getSymbolAtLocation(c, node) {
+    // API lookups shouldn't report errors.
+    return getSymbolAtLocationWorker(c, getReparsedNodeForNode(node), true);
+}
+/** The symbol a node refers to, reporting resolution errors unless `ignoreErrors`. */
+export function getSymbolAtLocationWorker(c, node, ignoreErrors) {
+    if (node.kind === 307 /* SyntaxKind.SourceFile */)
+        return isExternalOrCommonJSModule(node) ? getSymbolOfDeclaration(c, node) : undefined;
+    const parent = node.parent;
+    const grandParent = parent.parent;
+    // Semantic questions inside `with` blocks have no answer.
+    if ((node.flags & 16777216 /* NodeFlags.InWithStatement */) !== 0)
+        return undefined;
+    if (isDeclarationNameOrImportPropertyName(node)) {
+        const parentSymbol = getSymbolOfDeclaration(c, parent);
+        if (isImportOrExportSpecifier(parent) && getPropertyName(parent) === node)
+            return parentSymbol !== undefined ? getImmediateAliasedSymbol(c, parentSymbol) : undefined;
+        return parentSymbol;
+    }
+    if (isLiteralComputedPropertyDeclarationName(node))
+        return getSymbolOfDeclaration(c, grandParent);
+    if (node.kind === 79 /* SyntaxKind.Identifier */) {
+        if (isInRightSideOfImportOrExportAssignment(node))
+            return getSymbolOfNameOrPropertyAccessExpression(c, node);
+        if (parent.kind === 209 /* SyntaxKind.BindingElement */ &&
+            grandParent.kind === 207 /* 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) {
+            const meta = parent;
+            // `target` in `new.target`.
+            if (meta.keywordToken === 104 /* SyntaxKind.NewKeyword */ && getText(node) === 'target')
+                return checkNewTargetMetaProperty(c, parent).symbol;
+            // `meta` in `import.meta` is the declarationless `meta` member of a synthetic type.
+            if (meta.keywordToken === 101 /* SyntaxKind.ImportKeyword */ && getText(node) === 'meta')
+                return getGlobalImportMetaExpressionType(c).symbol.members.get('meta');
+            // Other meta properties are invalid syntax.
+            return undefined;
+        }
+        else if (parent.kind === 333 /* SyntaxKind.JSDocParameterTag */ && getName(parent) === node) {
+            const fn = getNodeAtPosition(getSourceFileOfNode(node), node.pos, false);
+            if (isFunctionLike(fn)) {
+                for (const param of getParameters(fn).nodes) {
+                    const name = getName(param);
+                    if (name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */ && getText(name) === getText(node))
+                        return getSymbolOfDeclaration(c, param);
+                }
+            }
+        }
+    }
+    switch (node.kind) {
+        case 79 /* SyntaxKind.Identifier */:
+        case 80 /* SyntaxKind.PrivateIdentifier */:
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 167 /* 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 */:
+            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;
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+            // Module names: `import x = require("m")`, import and export declarations, `require("m")`,
+            // `import("m")` and `import("m")` types.
+            if ((grandParent !== undefined &&
+                isExternalModuleImportEqualsDeclaration(grandParent) &&
+                grandParent.moduleReference.expression === node) ||
+                ((parent.kind === 273 /* SyntaxKind.ImportDeclaration */ ||
+                    parent.kind === 346 /* SyntaxKind.JSImportDeclaration */ ||
+                    parent.kind === 279 /* SyntaxKind.ExportDeclaration */) &&
+                    getExternalModuleName(parent) === node) ||
+                (grandParent !== undefined && isVariableDeclarationInitializedToRequire(grandParent)) ||
+                isImportCall(parent) ||
+                (parent.kind === 202 /* SyntaxKind.LiteralType */ &&
+                    grandParent !== undefined &&
+                    isLiteralImportTypeNode(grandParent) &&
+                    grandParent.argument === parent))
+                return resolveExternalModuleName(c, node, node, ignoreErrors);
+            if (parent.kind === 214 /* SyntaxKind.CallExpression */ &&
+                isBindableObjectDefinePropertyCall(parent) &&
+                getArguments(parent).nodes[1] === node)
+                return getSymbolOfDeclaration(c, parent);
+            return getSymbolOfLiteralIndex(c, node);
+        case 8 /* SyntaxKind.NumericLiteral */:
+            return getSymbolOfLiteralIndex(c, node);
+        case 89 /* SyntaxKind.DefaultKeyword */:
+        case 99 /* SyntaxKind.FunctionKeyword */:
+        case 38 /* SyntaxKind.EqualsGreaterThanToken */:
+        case 85 /* SyntaxKind.ClassKeyword */:
+            return getSymbolOfDeclaration(c, parent);
+        case 206 /* 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;
+        case 101 /* SyntaxKind.ImportKeyword */:
+            if (parent.kind === 237 /* SyntaxKind.MetaProperty */ && parent.name.text === 'defer')
+                return undefined;
+            return parent.kind === 237 /* SyntaxKind.MetaProperty */ ? checkMetaPropertyKeyword(c).symbol : undefined;
+        case 104 /* SyntaxKind.NewKeyword */:
+            return parent.kind === 237 /* SyntaxKind.MetaProperty */ ? checkMetaPropertyKeyword(c).symbol : undefined;
+        case 103 /* SyntaxKind.InstanceOfKeyword */:
+            if (parent.kind === 227 /* SyntaxKind.BinaryExpression */) {
+                const t = checkExpressionCached(c, parent.right);
+                const hasInstanceMethodType = getSymbolHasInstanceMethodOfObjectType(c, t);
+                if (hasInstanceMethodType !== undefined && hasInstanceMethodType.symbol !== undefined)
+                    return hasInstanceMethodType.symbol;
+                return t.symbol;
+            }
+            return undefined;
+        case 237 /* SyntaxKind.MetaProperty */:
+            return checkExpression(c, node).symbol;
+        case 296 /* SyntaxKind.JsxNamespacedName */:
+            if (isJsxTagName(node) && isJsxIntrinsicTagName(node)) {
+                const symbol = getIntrinsicTagSymbol(c, parent);
+                return symbol === c.unknownSymbol ? undefined : symbol;
+            }
+            return undefined;
+    }
+    return undefined;
+}
+/** The symbol of `this`: the function's `this` parameter, or the type `this` refers to. */
+function getSymbolOfThis(c, node) {
+    const container = getThisContainer(node, false, false);
+    if (isFunctionLike(container)) {
+        const signature = getSignatureFromDeclaration(c, container);
+        if (signature.thisParameter !== undefined)
+            return signature.thisParameter;
+    }
+    if (isInExpressionContext(node))
+        return checkExpression(c, node).symbol;
+    return getTypeFromThisTypeNode(c, node).symbol;
+}
+/** The property a literal index refers to, in `o["x"]` or `T["x"]`. */
+function getSymbolOfLiteralIndex(c, node) {
+    const parent = node.parent;
+    let objectType;
+    if (parent.kind === 213 /* SyntaxKind.ElementAccessExpression */) {
+        if (parent.argumentExpression === node)
+            objectType = checkExpressionCached(c, parent.expression);
+    }
+    else if (parent.kind === 202 /* SyntaxKind.LiteralType */ && parent.parent.kind === 200 /* SyntaxKind.IndexedAccessType */)
+        objectType = getTypeFromTypeNode(c, parent.parent.objectType);
+    return objectType !== undefined ? getPropertyOfType(c, objectType, getText(node)) : undefined;
+}
+function getSymbolOfNameOrPropertyAccessExpression(c, nameIn) {
+    let name = nameIn;
+    if (isDeclarationName(name))
+        return getSymbolOfDeclaration(c, name.parent);
+    if (name.parent.kind === 278 /* 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);
+        if (success !== undefined && success !== c.unknownSymbol)
+            return success;
+    }
+    else if (isEntityName(name) && isInRightSideOfImportOrExportAssignment(name)) {
+        // Export assignments were handled above, so this is an import.
+        return getSymbolOfPartOfRightHandSideOfImportEquals(c, name);
+    }
+    if (isEntityName(name)) {
+        const possibleImportNode = isImportTypeQualifierPart(name);
+        if (possibleImportNode !== undefined) {
+            getTypeFromTypeNode(c, possibleImportNode);
+            const symbol = c.resolvedSymbols.get(name.id);
+            return symbol === c.unknownSymbol ? undefined : symbol;
+        }
+    }
+    while (isRightSideOfQualifiedNameOrPropertyAccess(name))
+        name = name.parent;
+    if (isInNameOfExpressionWithTypeArguments(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.
+            meaning = isPartOfTypeNode(name) ? 788968 /* SymbolFlags.Type */ : 111551 /* SymbolFlags.Value */;
+            if (isExpressionWithTypeArgumentsInClassExtendsClause(name.parent))
+                meaning |= 111551 /* SymbolFlags.Value */;
+        }
+        else
+            meaning = 1920 /* SymbolFlags.Namespace */;
+        meaning |= 2097152 /* SymbolFlags.Alias */;
+        const entityNameSymbol = isEntityNameExpression(name)
+            ? resolveEntityName(c, name, meaning, true, false, undefined)
+            : undefined;
+        if (entityNameSymbol !== undefined)
+            return entityNameSymbol;
+    }
+    if (isExpressionNode(name)) {
+        // A missing entity name.
+        if (nodeIsMissing(name))
+            return undefined;
+        const isJSDoc = isJSDocNameReferenceContext(name);
+        if (name.kind === 79 /* SyntaxKind.Identifier */) {
+            if (isJsxTagName(name) && isJsxIntrinsicTagName(name)) {
+                const symbol = getIntrinsicTagSymbol(c, name.parent);
+                return symbol === c.unknownSymbol ? undefined : symbol;
+            }
+            const meaning = isJSDoc ? 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ : 111551 /* SymbolFlags.Value */;
+            const location = isJSDoc ? getHostSignatureFromJSDoc(name) : undefined;
+            let result = resolveEntityName(c, name, meaning, true, true, location);
+            if (result === undefined && isJSDoc) {
+                // Unqualified references to static members and instance members of a class or interface.
+                let container = name.parent;
+                while (container !== undefined && !isClassOrInterfaceLike(container))
+                    container = container.parent;
+                if (container !== undefined) {
+                    const symbol = getSymbolOfDeclaration(c, container);
+                    const member = getExportsOfSymbol(c, symbol).get(getText(name));
+                    result =
+                        member !== undefined && (member.flags & meaning) !== 0
+                            ? getMergedSymbol(c, member)
+                            : getPropertyOfType(c, getDeclaredTypeOfSymbol(c, symbol), getText(name));
+                }
+            }
+            return result;
+        }
+        if (name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
+            return getSymbolForPrivateIdentifierExpression(c, name);
+        if (name.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || name.kind === 167 /* SyntaxKind.QualifiedName */) {
+            const cached = c.resolvedSymbols.get(name.id);
+            if (cached !== undefined)
+                return cached;
+            if (name.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+                const access = name;
+                checkPropertyAccessExpression(c, access, false);
+                if (c.resolvedSymbols.get(name.id) === undefined && access.name.kind !== 80 /* SyntaxKind.PrivateIdentifier */)
+                    c.resolvedSymbols.set(name.id, getApplicableIndexSymbol(c, checkExpressionCached(c, access.expression), getLiteralTypeFromPropertyName(c, access.name) ?? c.errorType));
+            }
+            else
+                checkQualifiedName(c, name);
+            if (c.resolvedSymbols.get(name.id) === undefined && isJSDoc && name.kind === 167 /* 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 symbol = resolveEntityName(c, name, meaning, true, true, undefined);
+        if (symbol !== undefined && symbol !== c.unknownSymbol)
+            return symbol;
+        return getUnresolvedSymbolForEntityName(c, name);
+    }
+    if (name.parent.kind === 183 /* SyntaxKind.TypePredicate */)
+        return resolveEntityName(c, name, 1 /* SymbolFlags.FunctionScopedVariable */, true, false, undefined);
+    return undefined;
+}
+/** A property symbol for the index signatures of `t` that apply to `keyType`, made once per signature. */
+function getApplicableIndexSymbol(c, t, keyType) {
+    const info = getApplicableIndexInfo(c, t, keyType);
+    if (info === undefined || info === c.anyBaseTypeIndexInfo)
+        return undefined;
+    if (info.indexSymbol === undefined) {
+        const declarations = [];
+        if (info.declaration !== undefined)
+            declarations.push(info.declaration);
+        else
+            for (const other of getIndexInfosOfType(c, t))
+                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 */);
+            setDeclarations(symbol, declarations);
+            symbol.valueDeclaration = declarations[0];
+            symbol.parent = t.symbol;
+            c.symbolTypes.set(getSymbolId(symbol), info.valueType);
+            info.indexSymbol = symbol;
+        }
+    }
+    return info.indexSymbol;
+}
+/** The type of `import.meta` as an expression: `{ meta: ImportMeta }`. */
+function getGlobalImportMetaExpressionType(c) {
+    let t = c.importMetaExpressionType;
+    if (t === undefined) {
+        const symbol = c.newSymbol(0 /* SymbolFlags.None */, 'ImportMetaExpression');
+        const metaProperty = c.newSymbolWithCheckFlags(4 /* SymbolFlags.Property */, 'meta', 8 /* CheckFlags.Readonly */);
+        metaProperty.parent = symbol;
+        c.symbolTypes.set(getSymbolId(metaProperty), getCachedGlobalType(c, 'ImportMeta', 0, true));
+        const members = new Map();
+        members.set('meta', metaProperty);
+        symbol.members = members;
+        t = createAnonymousType(c, symbol, members, [], [], []);
+        c.importMetaExpressionType = t;
+    }
+    return t;
+}
+/** The type of the `import` or `new` keyword of a meta property, which has none. */
+function checkMetaPropertyKeyword(c) {
+    return c.errorType;
+}
+// ---- Types at locations
+/** The type of the expression, type node or declaration at `node`. */
+export function getTypeAtLocation(c, node) {
+    return getTypeOfNode(c, getReparsedNodeForNode(node));
+}
+function getTypeOfNode(c, node) {
+    if (node.kind === 307 /* 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 classType = heritage !== undefined ? getDeclaredTypeOfClassOrInterface(c, getSymbolOfDeclaration(c, heritage)) : undefined;
+    if (isPartOfTypeNode(node)) {
+        const typeFromTypeNode = getTypeFromTypeNode(c, node);
+        return classType !== undefined
+            ? getTypeWithThisArgument(c, typeFromTypeNode, classType.thisType, false)
+            : typeFromTypeNode;
+    }
+    if (isExpressionNode(node))
+        return getRegularTypeOfExpression(c, node);
+    if (classType !== undefined && !isImplementsExpression(node)) {
+        // An expression with type arguments in a class `extends` clause is the base type.
+        const baseTypes = getBaseTypes(c, classType);
+        return baseTypes.length > 0 ? getTypeWithThisArgument(c, baseTypes[0], classType.thisType, false) : c.errorType;
+    }
+    if (isTypeDeclaration(node))
+        return getDeclaredTypeOfSymbol(c, getSymbolOfDeclaration(c, node));
+    if (isTypeDeclarationName(node)) {
+        const symbol = getSymbolAtLocationWorker(c, node, false);
+        return symbol !== undefined ? getDeclaredTypeOfSymbol(c, symbol) : c.errorType;
+    }
+    if (node.kind === 209 /* SyntaxKind.BindingElement */)
+        return getTypeForVariableLikeDeclaration(c, node, true) ?? c.errorType;
+    if (isDeclaration(node)) {
+        const symbol = getSymbolOfDeclaration(c, node);
+        return symbol !== undefined ? getTypeOfSymbol(c, symbol) : c.errorType;
+    }
+    if (isDeclarationNameOrImportPropertyName(node)) {
+        const symbol = getSymbolAtLocationWorker(c, node, false);
+        return symbol !== undefined ? getTypeOfSymbol(c, symbol) : c.errorType;
+    }
+    if (isBindingPattern(node))
+        return getTypeForVariableLikeDeclaration(c, node.parent, true) ?? c.errorType;
+    if (isInRightSideOfImportOrExportAssignment(node)) {
+        const symbol = getSymbolAtLocationWorker(c, node, false);
+        if (symbol !== undefined) {
+            const declaredType = getDeclaredTypeOfSymbol(c, symbol);
+            return !isErrorType(c, declaredType) ? declaredType : getTypeOfSymbol(c, symbol);
+        }
+    }
+    const parent = node.parent;
+    if (parent !== undefined &&
+        parent.kind === 237 /* SyntaxKind.MetaProperty */ &&
+        parent.keywordToken === node.kind)
+        return checkMetaPropertyKeyword(c);
+    if (node.kind === 301 /* SyntaxKind.ImportAttributes */)
+        return getCachedGlobalType(c, 'ImportAttributes', 0, true);
+    return c.errorType;
+}
+function getRegularTypeOfExpression(c, node) {
+    const expr = isRightSideOfQualifiedNameOrPropertyAccess(node) ? node.parent : node;
+    return getRegularTypeOfLiteralType(c, checkExpressionCached(c, expr));
+}
+/** The narrowed type of `symbol` at `location`, or its declared type when `location` doesn't reference it. */
+export function getTypeOfSymbolAtLocation(c, symbolIn, locationIn) {
+    const symbol = getExportSymbolOfValueSymbolIfExported(c, symbolIn);
+    let location = locationIn;
+    if (location !== undefined) {
+        // 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 */)) {
+            if (isRightSideOfQualifiedNameOrPropertyAccess(location))
+                location = location.parent;
+            if (isExpressionNode(location) && (!isAssignmentTarget(location) || isWriteAccess(location))) {
+                const t = checkExpressionCached(c, location);
+                const resolved = c.resolvedSymbols.get(location.id);
+                if (resolved !== undefined && getExportSymbolOfValueSymbolIfExported(c, resolved) === symbol)
+                    return removeOptionalTypeMarker(c, t);
+            }
+        }
+        if (isDeclarationName(location) &&
+            location.parent.kind === 179 /* 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.
+        if (isRightSideOfAccessExpression(location) && isWriteAccess(location.parent))
+            return getWriteTypeOfSymbol(c, symbol);
+    }
+    return getNonMissingTypeOfSymbol(c, symbol);
+}
+// ---- 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 */)
+        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 */) {
+        const exportDeclaration = node.parent.parent;
+        if (getExternalModuleName(exportDeclaration) !== undefined)
+            return getExternalModuleMember(c, exportDeclaration, node, false);
+        const specifier = node;
+        const name = specifier.propertyName ?? specifier.name;
+        // Invalid syntax like `export { "x" }`.
+        if (name.kind === 10 /* SyntaxKind.StringLiteral */)
+            return undefined;
+        return resolveEntityName(c, name, meaning, true, false, undefined);
+    }
+    if (node.kind === 79 /* SyntaxKind.Identifier */)
+        return resolveEntityName(c, node, meaning, true, false, undefined);
+    throw new Error('getExportSpecifierLocalTargetSymbol expects an export specifier or identifier');
+}
+/** 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 */)
+        return getEnumMemberValue(c, node);
+    // Checking the expression records the symbol it resolves to.
+    if (c.resolvedSymbols.get(node.id) === undefined)
+        checkExpressionCached(c, node);
+    let symbol = c.resolvedSymbols.get(node.id);
+    if (symbol === undefined && isEntityNameExpression(node))
+        symbol = resolveEntityName(c, node, 111551 /* SymbolFlags.Value */, true, false, undefined);
+    if (symbol !== undefined && (symbol.flags & 8 /* SymbolFlags.EnumMember */) !== 0) {
+        // Only const enum accesses are inlined.
+        const member = symbol.valueDeclaration;
+        if (isEnumConst(member.parent))
+            return getEnumMemberValue(c, member);
+    }
+    return undefined;
+}
+function getEnumMemberValue(c, member) {
+    computeEnumMemberValues(c, member.parent);
+    const links = c.nodeLinks(member);
+    if (links.enumValueKind === 1 /* EvaluatedKind.Number */)
+        return links.enumNumberValue;
+    if (links.enumValueKind === 2 /* EvaluatedKind.String */)
+        return links.enumStringValue;
+    return undefined;
+}
+/** The symbol an alias refers to directly, without following further aliases. Throws for non-aliases. */
+export function getImmediateAliasedSymbol(c, symbol) {
+    const links = c.symbolLinks(symbol);
+    if (links.immediateTarget === undefined) {
+        const node = getDeclarationOfAliasSymbol(symbol);
+        if (node === undefined)
+            throw new Error('getImmediateAliasedSymbol expects an alias symbol');
+        links.immediateTarget = getTargetOfAliasDeclaration(c, node);
+    }
+    return links.immediateTarget;
+}
+/** The export of a module named `name`. */
+export function tryGetMemberInModuleExports(c, name, moduleSymbol) {
+    return getExportsOfModule(c, moduleSymbol).get(name);
+}
+/** The exports of a module, without reserved names like `export=`. */
+export function getExportsOfModuleAsArray(c, moduleSymbol) {
+    const result = [];
+    for (const [name, symbol] of getExportsOfModule(c, moduleSymbol))
+        if (!isReservedMemberName(name))
+            result.push(symbol);
+    return result;
+}
+/** The element type of a signature's rest parameter, or `any` without one. */
+export function getRestTypeOfSignature(c, signature) {
+    return tryGetRestTypeOfSignature(c, signature) ?? c.anyType;
+}
+/**
+ * The signature of a function-like declaration. Declarations and call-like expressions share the
+ * cached signature, so a call that was resolved gives its signature; other nodes throw.
+ */
+export function querySignatureFromDeclaration(c, node) {
+    const cached = c.resolvedSignatures.get(node.id);
+    if (cached !== undefined)
+        return cached;
+    if (!isFunctionLike(node))
+        throw new Error('getSignatureFromDeclaration expects a function-like declaration');
+    return getSignatureFromDeclaration(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 */:
+            return getResolvedSignature(c, node, 0 /* CheckMode.Normal */);
+    }
+    throw new Error('getResolvedSignature expects a call-like expression');
+}
+/** The contextual type of an expression. Throws for a source file, which has no parent. */
+export function queryContextualType(c, node) {
+    if (node.parent === undefined)
+        throw new Error('getContextualType expects a node with a parent');
+    // Semantic questions inside `with` blocks have no answer.
+    if ((node.flags & 16777216 /* NodeFlags.InWithStatement */) !== 0)
+        return undefined;
+    return getContextualType(c, node);
+}
+// ---- Syntax
+/**
+ * The node a JSDoc node was reparsed into, if any: types and declarations written in JSDoc are
+ * checked as clones in the tree.
+ */
+export function getReparsedNodeForNode(node) {
+    if ((node.flags & 4194304 /* NodeFlags.JSDoc */) === 0 || (node.flags & 8 /* NodeFlags.Reparsed */) !== 0)
+        return node;
+    const clones = getSourceFileOfNode(node).reparsedClones;
+    if (clones.length === 0)
+        return node;
+    let low = 0;
+    let high = clones.length - 1;
+    let index = -1;
+    while (low <= high) {
+        const middle = low + ((high - low) >> 1);
+        const cmp = compareNodePositions(clones[middle], node);
+        if (cmp < 0)
+            low = middle + 1;
+        else if (cmp > 0)
+            high = middle - 1;
+        else {
+            index = middle;
+            break;
+        }
+    }
+    if (index < 0)
+        index = low > 0 ? low - 1 : 0;
+    const candidate = clones[index];
+    if (candidate.pos <= node.pos && node.end <= candidate.end) {
+        const clone = findCloneInNode(candidate, node);
+        if (clone !== undefined)
+            return clone;
+    }
+    return node;
+}
+function findCloneInNode(root, original) {
+    let node = root;
+    for (;;) {
+        if (node.kind === original.kind && node.pos === original.pos && node.end === original.end)
+            return node;
+        let next;
+        for (const child of childrenOf(node))
+            if (child.pos <= original.pos && original.end <= child.end) {
+                next = child;
+                break;
+            }
+        if (next === undefined)
+            return undefined;
+        node = next;
+    }
+}
+function childrenOf(node) {
+    const result = [];
+    node.forEachChild(new ChildCollector(result));
+    return result;
+}
+class ChildCollector extends NodeVisitor {
+    nodes;
+    constructor(nodes) {
+        super();
+        this.nodes = nodes;
+    }
+    visitNode(node) {
+        this.nodes.push(node);
+        return false;
+    }
+}
+export function isEntityName(node) {
+    return node.kind === 79 /* SyntaxKind.Identifier */ || node.kind === 167 /* SyntaxKind.QualifiedName */;
+}
+function isBindingPattern(node) {
+    return node.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 208 /* SyntaxKind.ArrayBindingPattern */;
+}
+function isImportOrExportSpecifier(node) {
+    return node.kind === 277 /* SyntaxKind.ImportSpecifier */ || node.kind === 282 /* SyntaxKind.ExportSpecifier */;
+}
+function isClassOrInterfaceLike(node) {
+    return (node.kind === 264 /* SyntaxKind.ClassDeclaration */ ||
+        node.kind === 232 /* SyntaxKind.ClassExpression */ ||
+        node.kind === 265 /* SyntaxKind.InterfaceDeclaration */);
+}
+function isJSDocLinkLike(node) {
+    return (node.kind === 319 /* SyntaxKind.JSDocLink */ ||
+        node.kind === 320 /* SyntaxKind.JSDocLinkCode */ ||
+        node.kind === 321 /* SyntaxKind.JSDocLinkPlain */);
+}
+export function isDeclaration(node) {
+    if (node.kind === 169 /* SyntaxKind.TypeParameter */)
+        return node.parent !== undefined;
+    return isDeclarationNode(node);
+}
+export function isDeclarationName(name) {
+    return (name.kind !== 307 /* SyntaxKind.SourceFile */ &&
+        !isBindingPattern(name) &&
+        isDeclaration(name.parent) &&
+        getName(name.parent) === name);
+}
+/** Like `isDeclarationName`, but also the left of `import { x as y }` and `export { x as y }`. */
+function isDeclarationNameOrImportPropertyName(name) {
+    if (isImportOrExportSpecifier(name.parent))
+        return name.kind === 79 /* SyntaxKind.Identifier */ || name.kind === 10 /* SyntaxKind.StringLiteral */;
+    return isDeclarationName(name);
+}
+export function isLiteralComputedPropertyDeclarationName(node) {
+    return ((isStringLiteralLike(node) || node.kind === 8 /* SyntaxKind.NumericLiteral */) &&
+        node.parent.kind === 168 /* SyntaxKind.ComputedPropertyName */ &&
+        isDeclaration(node.parent.parent));
+}
+function isExternalModuleImportEqualsDeclaration(node) {
+    return (node.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */ &&
+        node.moduleReference.kind === 284 /* SyntaxKind.ExternalModuleReference */);
+}
+export function isInRightSideOfImportOrExportAssignment(nodeIn) {
+    let node = nodeIn;
+    while (node.parent.kind === 167 /* SyntaxKind.QualifiedName */)
+        node = node.parent;
+    const parent = node.parent;
+    return ((parent.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */ &&
+        parent.moduleReference === node) ||
+        (parent.kind === 278 /* 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 */) {
+        node = parent;
+        parent = parent.parent;
+    }
+    if (parent !== undefined && parent.kind === 206 /* SyntaxKind.ImportType */ && parent.qualifier === node)
+        return parent;
+    return undefined;
+}
+function isInNameOfExpressionWithTypeArguments(nodeIn) {
+    let node = nodeIn;
+    while (node.parent.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+        node = node.parent;
+    return node.parent.kind === 234 /* SyntaxKind.ExpressionWithTypeArguments */;
+}
+export function isRightSideOfQualifiedNameOrPropertyAccess(node) {
+    const parent = node.parent;
+    switch (parent.kind) {
+        case 167 /* SyntaxKind.QualifiedName */:
+            return parent.right === node;
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+            return parent.name === node;
+        case 237 /* SyntaxKind.MetaProperty */:
+            return parent.name === node;
+    }
+    return false;
+}
+function isRightSideOfAccessExpression(node) {
+    const parent = node.parent;
+    if (parent === undefined)
+        return false;
+    if (parent.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+        return parent.name === node;
+    if (parent.kind === 213 /* 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 */:
+            return getTagName(parent) === node;
+    }
+    return false;
+}
+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))
+            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 undefined;
+    const parent = node.parent;
+    return parent.kind === 299 /* SyntaxKind.HeritageClause */ && isClassLike(parent.parent) ? parent.parent : undefined;
+}
+function isImplementsExpression(node) {
+    return node.parent.token === 118 /* SyntaxKind.ImplementsKeyword */;
+}
+function isExpressionWithTypeArgumentsInClassExtendsClause(node) {
+    return getClassOfHeritageExpression(node) !== undefined && !isImplementsExpression(node);
+}
+function isTypeDeclarationName(name) {
+    return (name.kind === 79 /* SyntaxKind.Identifier */ && isTypeDeclaration(name.parent) && getNameOfDeclaration(name.parent) === 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 */)
+        node = node.parent;
+    return node.parent.kind === 184 /* SyntaxKind.TypeReference */;
+}
+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.kind !== 223 /* SyntaxKind.VoidExpression */;
+        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+            return isPartOfTypeExpressionWithTypeArguments(node);
+        case 169 /* SyntaxKind.TypeParameter */:
+            return node.parent.kind === 201 /* SyntaxKind.MappedType */ || node.parent.kind === 196 /* SyntaxKind.InferType */;
+        case 79 /* SyntaxKind.Identifier */: {
+            const parent = node.parent;
+            if (parent.kind === 167 /* SyntaxKind.QualifiedName */ && parent.right === node)
+                return isPartOfTypeNodeInParent(parent);
+            if (parent.kind === 212 /* SyntaxKind.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 isPartOfTypeExpressionWithTypeArguments(node) {
+    const parent = node.parent;
+    return ((parent.kind === 299 /* SyntaxKind.HeritageClause */ &&
+        (!isClassLike(parent.parent) || parent.token === 118 /* SyntaxKind.ImplementsKeyword */)) ||
+        parent.kind === 324 /* SyntaxKind.JSDocImplementsTag */ ||
+        parent.kind === 323 /* 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 */)
+        return false;
+    if (parent.kind === 206 /* SyntaxKind.ImportType */)
+        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 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 */:
+            return node === getType(parent);
+        case 214 /* SyntaxKind.CallExpression */:
+        case 215 /* SyntaxKind.NewExpression */:
+        case 216 /* SyntaxKind.TaggedTemplateExpression */: {
+            const typeArguments = getTypeArguments(parent);
+            return typeArguments !== undefined && typeArguments.nodes.includes(node);
+        }
+    }
+    return false;
+}
+export function isExpressionNode(nodeIn) {
+    let node = nodeIn;
+    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 */:
+            // `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 */)
+                node = node.parent;
+            return isNameReferenceParent(node) || isJsxTagName(node);
+        case 80 /* SyntaxKind.PrivateIdentifier */: {
+            const parent = node.parent;
+            return (parent.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+                parent.left === node &&
+                parent.operatorToken.kind === 102 /* SyntaxKind.InKeyword */);
+        }
+        case 79 /* SyntaxKind.Identifier */:
+            if (isNameReferenceParent(node) || 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;
+}
+/** 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 */);
+}
+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 */:
+            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 */: {
+            const s = parent;
+            return ((s.initializer === node && node.kind !== 262 /* SyntaxKind.VariableDeclarationList */) ||
+                s.condition === node ||
+                s.incrementor === node);
+        }
+        case 250 /* SyntaxKind.ForInStatement */:
+        case 251 /* SyntaxKind.ForOfStatement */: {
+            const s = parent;
+            return (s.initializer === node && node.kind !== 262 /* SyntaxKind.VariableDeclarationList */) || s.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.objectAssignmentInitializer === node;
+    }
+    return isExpressionNode(parent);
+}
+function isWriteAccess(node) {
+    return accessKind(node) !== 0 /* AccessKind.Read */;
+}
+function accessKind(node) {
+    const parent = node.parent;
+    if (parent === undefined)
+        return 0 /* AccessKind.Read */;
+    switch (parent.kind) {
+        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+            return accessKind(parent);
+        case 225 /* SyntaxKind.PrefixUnaryExpression */:
+        case 226 /* SyntaxKind.PostfixUnaryExpression */: {
+            const operator = parent.kind === 225 /* 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 */: {
+            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 */:
+            return parent.name !== node ? 0 /* AccessKind.Read */ : accessKind(parent);
+        case 303 /* SyntaxKind.PropertyAssignment */: {
+            const parentAccess = accessKind(parent.parent);
+            // In `({ x: v } = o)`, the `x` is read and `v` written.
+            if (node === getName(parent)) {
+                if (parentAccess === 0 /* AccessKind.Read */)
+                    return 1 /* AccessKind.Write */;
+                if (parentAccess === 1 /* AccessKind.Write */)
+                    return 0 /* AccessKind.Read */;
+                return 2 /* AccessKind.ReadWrite */;
+            }
+            return parentAccess;
+        }
+        case 304 /* 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 */:
+            return node === parent.initializer ? 1 /* AccessKind.Write */ : 0 /* AccessKind.Read */;
+    }
+    return 0 /* AccessKind.Read */;
+}