@zzzen/pyright-internal 1.2.0-dev.20261018 → 1.2.0-dev.20261108

package/dist/analyzer/typeEvaluator/memberResolution.js

@@ -0,0 +1,1007 @@
+"use strict";
+/*
+ * memberResolution.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * memberResolution implementation, using evaluator-owned dependencies and state.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMemberResolution = createMemberResolution;
+const collectionUtils_1 = require("../../common/collectionUtils");
+const debug_1 = require("../../common/debug");
+const diagnostic_1 = require("../../common/diagnostic");
+const diagnosticRules_1 = require("../../common/diagnosticRules");
+const localize_1 = require("../../localization/localize");
+const analyzerFileInfo_1 = require("../analyzerFileInfo");
+const constructors_1 = require("../constructors");
+const declarationUtils_1 = require("../declarationUtils");
+const parameterUtils_1 = require("../parameterUtils");
+const ParseTreeUtils = __importStar(require("../parseTreeUtils"));
+const typeEvaluatorTypes_1 = require("../typeEvaluatorTypes");
+const types_1 = require("../types");
+const typeUtils_1 = require("../typeUtils");
+// Resolves names, members and declarations; member return types are inferred before specialization.
+function createMemberResolution(context) {
+    const { addClassEntryDeclsForKeywordArgIfPresent: _addClassEntryDeclsForKeywordArgIfPresent, addSymbolDeclInfo: _addSymbolDeclInfo, shouldFallBackToClassEntryForKeywordArg: _shouldFallBackToClassEntryForKeywordArg, tryAddPartialKeywordParamDecls: _tryAddPartialKeywordParamDecls, addDiagnostic, codeFlowEngine, evaluateTypesForStatement, evaluatorOptions, getAbstractSymbolInfo, getBoundMagicMethod, getEffectiveTypeOfSymbol, getEffectiveTypeOfSymbolForUsage, getExpectedType, getInferredTypeOfDeclaration, getScopeForNode, getScopeIdForNode, getType, getTypeClassType, getTypeOfAnnotation, getTypeOfBoundMember, getTypeOfClass, getTypeOfFunction, inferReturnTypeIfNecessary, isFlowPathBetweenNodes, isLegalTypeAliasExpressionForm, isSymbolValidTypeExpression, makeTopLevelTypeVarsConcrete, nodeInfo, partiallySpecializeBoundMethod, resolveAliasDeclarationWithInfo, symbolResolutionStack, validateCallArgs, validateInitSubclassArgs, } = context;
+    function getIndexOfSymbolResolution(symbol, declaration) {
+        return symbolResolutionStack.findIndex((entry) => entry.symbolId === symbol.id && entry.declaration === declaration);
+    }
+    function pushSymbolResolution(symbol, declaration) {
+        const index = getIndexOfSymbolResolution(symbol, declaration);
+        if (index >= 0) {
+            // Mark all of the entries between these two as invalid.
+            for (let i = index + 1; i < symbolResolutionStack.length; i++) {
+                symbolResolutionStack[i].isResultValid = false;
+            }
+            return false;
+        }
+        symbolResolutionStack.push({
+            symbolId: symbol.id,
+            declaration,
+            isResultValid: true,
+        });
+        return true;
+    }
+    function popSymbolResolution(symbol) {
+        const poppedEntry = symbolResolutionStack.pop();
+        (0, debug_1.assert)(poppedEntry !== undefined && poppedEntry.symbolId === symbol.id, `Symbol resolution stack mismatch: expected symbol ${symbol.id}, got ${poppedEntry?.symbolId ?? 'empty stack'}`);
+        return poppedEntry.isResultValid;
+    }
+    function setSymbolResolutionPartialType(symbol, declaration, type) {
+        const index = getIndexOfSymbolResolution(symbol, declaration);
+        if (index >= 0) {
+            symbolResolutionStack[index].partialType = type;
+        }
+    }
+    function getSymbolResolutionPartialType(symbol, declaration) {
+        const index = getIndexOfSymbolResolution(symbol, declaration);
+        if (index >= 0) {
+            return symbolResolutionStack[index].partialType;
+        }
+        return undefined;
+    }
+    function isDeclaredTypeAlias(expression) {
+        if (expression.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
+            if (expression.d.valueExpr.nodeType === 38 /* ParseNodeType.Name */) {
+                const symbolWithScope = lookUpSymbolRecursive(expression, expression.d.valueExpr.d.value, 
+                /* honorCodeFlow */ false);
+                if (symbolWithScope) {
+                    const symbol = symbolWithScope.symbol;
+                    return symbol.getDeclarations().find((decl) => isExplicitTypeAliasDeclaration(decl)) !== undefined;
+                }
+            }
+        }
+        return false;
+    }
+    function validateSymbolIsTypeExpression(node, type, includesVarDecl) {
+        if (isSymbolValidTypeExpression(type, includesVarDecl)) {
+            return type;
+        }
+        // Disable for assignments in the typings.pyi file, since it defines special forms.
+        const fileInfo = nodeInfo.getFileInfo(node);
+        if (fileInfo.isTypingStubFile) {
+            return type;
+        }
+        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationVariable(), node);
+        return types_1.UnknownType.create();
+    }
+    function getTypeOfMember(member) {
+        if ((0, types_1.isInstantiableClass)(member.classType)) {
+            return (0, typeUtils_1.partiallySpecializeType)(getEffectiveTypeOfSymbol(member.symbol), member.classType, getTypeClassType(), 
+            /* selfClass */ undefined);
+        }
+        return types_1.UnknownType.create();
+    }
+    function getTypeOfMemberInternal(errorNode, member, selfClass, flags) {
+        if ((0, types_1.isAnyOrUnknown)(member.classType)) {
+            return {
+                type: member.classType,
+                isIncomplete: false,
+            };
+        }
+        if (!(0, types_1.isInstantiableClass)(member.classType)) {
+            return undefined;
+        }
+        const typeResult = getEffectiveTypeOfSymbolForUsage(member.symbol);
+        if (!typeResult) {
+            return undefined;
+        }
+        // Report inappropriate use of variables in type expressions.
+        if ((flags & 2048 /* MemberAccessFlags.TypeExpression */) !== 0 && errorNode) {
+            typeResult.type = validateSymbolIsTypeExpression(errorNode, typeResult.type, !!typeResult.includesVariableDecl);
+        }
+        // If the type is a function or overloaded function, infer
+        // and cache the return type if necessary. This needs to be done
+        // prior to specializing.
+        inferReturnTypeIfNecessary(typeResult.type);
+        // Check for ambiguous accesses to attributes with generic types?
+        if (errorNode &&
+            selfClass &&
+            (0, types_1.isClass)(selfClass) &&
+            member.isInstanceMember &&
+            (0, types_1.isClass)(member.unspecializedClassType) &&
+            (flags & 1024 /* MemberAccessFlags.DisallowGenericInstanceVariableAccess */) !== 0 &&
+            (0, typeUtils_1.requiresSpecialization)(typeResult.type, { ignoreSelf: true, ignoreImplicitTypeArgs: true })) {
+            const specializedType = (0, typeUtils_1.partiallySpecializeType)(typeResult.type, member.unspecializedClassType, getTypeClassType(), (0, typeUtils_1.selfSpecializeClass)(selfClass, { overrideTypeArgs: true }));
+            if ((0, types_1.findSubtype)(specializedType, (subtype) => !(0, types_1.isFunctionOrOverloaded)(subtype) &&
+                (0, typeUtils_1.requiresSpecialization)(subtype, { ignoreSelf: true, ignoreImplicitTypeArgs: true }))) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.genericInstanceVariableAccess(), errorNode);
+            }
+        }
+        return {
+            type: (0, typeUtils_1.partiallySpecializeType)(typeResult.type, member.classType, getTypeClassType(), selfClass),
+            isIncomplete: !!typeResult.isIncomplete,
+        };
+    }
+    function bindMethodForMemberAccess(type, concreteType, memberInfo, classType, selfType, flags, memberName, usage, diag, recursionCount = 0) {
+        // Check for an attempt to overwrite a final method.
+        if (usage.method === 'set') {
+            const impl = (0, types_1.isFunction)(concreteType) ? concreteType : types_1.OverloadedType.getImplementation(concreteType);
+            if (impl && (0, types_1.isFunction)(impl) && types_1.FunctionType.isFinal(impl) && memberInfo && (0, types_1.isClass)(memberInfo.classType)) {
+                diag?.addMessage(localize_1.LocMessage.finalMethodOverride().format({
+                    name: memberName,
+                    className: memberInfo.classType.shared.name,
+                }));
+                return { type: types_1.UnknownType.create(), typeErrors: true };
+            }
+        }
+        // If this function is an instance member (e.g. a lambda that was
+        // assigned to an instance variable), don't perform any binding.
+        if (types_1.TypeBase.isInstance(classType)) {
+            if (!memberInfo || memberInfo.isInstanceMember) {
+                return { type: type };
+            }
+        }
+        const boundType = bindFunctionToClassOrObject(classType, concreteType, memberInfo && (0, types_1.isInstantiableClass)(memberInfo.classType) ? memberInfo.classType : undefined, (flags & 256 /* MemberAccessFlags.TreatConstructorAsClassMethod */) !== 0, selfType && (0, types_1.isClass)(selfType) ? types_1.ClassType.cloneIncludeSubclasses(selfType) : selfType, diag, recursionCount);
+        return { type: boundType ?? types_1.UnknownType.create(), typeErrors: !boundType };
+    }
+    function isAsymmetricDescriptorClass(classType) {
+        // If the value has already been cached in this type, return the cached value.
+        if (classType.priv.isAsymmetricDescriptor !== undefined) {
+            return classType.priv.isAsymmetricDescriptor;
+        }
+        let isAsymmetric = false;
+        // Accessors can be defined at different levels of the descriptor's MRO.
+        // Ignore instance members so an instance attribute that happens to share
+        // a dunder name doesn't shadow the descriptor protocol during this check.
+        const accessorFlags = 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */;
+        const getterSymbolResult = (0, typeUtils_1.lookUpClassMember)(classType, '__get__', accessorFlags);
+        const setterSymbolResult = (0, typeUtils_1.lookUpClassMember)(classType, '__set__', accessorFlags);
+        if (!getterSymbolResult || !setterSymbolResult) {
+            isAsymmetric = false;
+        }
+        else {
+            let getterType = getTypeOfMember(getterSymbolResult);
+            let setterType = getTypeOfMember(setterSymbolResult);
+            // The getter and setter can be declared on different classes. Specialize
+            // both against the concrete descriptor class so Self and inherited type
+            // variables are compared in the same context.
+            if (getterSymbolResult.classType && (0, types_1.isInstantiableClass)(getterSymbolResult.classType)) {
+                getterType = (0, typeUtils_1.partiallySpecializeType)(getterType, getterSymbolResult.classType, getTypeClassType(), classType);
+            }
+            if (setterSymbolResult.classType && (0, types_1.isInstantiableClass)(setterSymbolResult.classType)) {
+                setterType = (0, typeUtils_1.partiallySpecializeType)(setterType, setterSymbolResult.classType, getTypeClassType(), classType);
+            }
+            // If this is an overload, find the appropriate overload.
+            if ((0, types_1.isOverloaded)(getterType)) {
+                const getOverloads = types_1.OverloadedType.getOverloads(getterType).filter((overload) => {
+                    if (overload.shared.parameters.length < 2) {
+                        return false;
+                    }
+                    const param1Type = types_1.FunctionType.getParamType(overload, 1);
+                    return !(0, typeUtils_1.isNoneInstance)(param1Type);
+                });
+                if (getOverloads.length === 1) {
+                    getterType = getOverloads[0];
+                }
+                else {
+                    isAsymmetric = true;
+                }
+            }
+            // If this is an overload, find the appropriate overload.
+            if ((0, types_1.isOverloaded)(setterType)) {
+                isAsymmetric = true;
+            }
+            // If either the setter or getter is an overload (or some other non-function type),
+            // conservatively assume that it's not asymmetric.
+            if ((0, types_1.isFunction)(getterType) && (0, types_1.isFunction)(setterType)) {
+                // If there's no declared return type on the getter, assume it's symmetric.
+                if (setterType.shared.parameters.length >= 3 && getterType.shared.declaredReturnType) {
+                    const setterValueType = types_1.FunctionType.getParamType(setterType, 2);
+                    const getterReturnType = types_1.FunctionType.getEffectiveReturnType(getterType) ?? types_1.UnknownType.create();
+                    if (!(0, types_1.isTypeSame)(setterValueType, getterReturnType)) {
+                        isAsymmetric = true;
+                    }
+                }
+            }
+        }
+        // Cache the value for next time.
+        classType.priv.isAsymmetricDescriptor = isAsymmetric;
+        return isAsymmetric;
+    }
+    function applyAttributeAccessOverride(errorNode, classType, usage, memberName, selfType) {
+        const getAttributeAccessMember = (name) => {
+            return getTypeOfBoundMember(errorNode, classType, name, 
+            /* usage */ undefined, 
+            /* diag */ undefined, 16 /* MemberAccessFlags.SkipInstanceMembers */ |
+                4 /* MemberAccessFlags.SkipObjectBaseClass */ |
+                8 /* MemberAccessFlags.SkipTypeBaseClass */ |
+                512 /* MemberAccessFlags.SkipAttributeAccessOverride */, selfType)?.type;
+        };
+        let accessMemberType;
+        if (usage.method === 'get') {
+            accessMemberType = getAttributeAccessMember('__getattribute__') ?? getAttributeAccessMember('__getattr__');
+        }
+        else if (usage.method === 'set') {
+            accessMemberType = getAttributeAccessMember('__setattr__');
+        }
+        else {
+            (0, debug_1.assert)(usage.method === 'del');
+            accessMemberType = getAttributeAccessMember('__delattr__');
+        }
+        if (!accessMemberType) {
+            return undefined;
+        }
+        const argList = [];
+        // Provide "name" argument.
+        argList.push({
+            argCategory: 0 /* ArgCategory.Simple */,
+            typeResult: {
+                type: context.prefetched?.strClass && (0, types_1.isInstantiableClass)(context.prefetched.strClass)
+                    ? types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneAsInstance(context.prefetched.strClass), memberName)
+                    : types_1.AnyType.create(),
+            },
+        });
+        if (usage.method === 'set') {
+            // Provide "value" argument.
+            argList.push({
+                argCategory: 0 /* ArgCategory.Simple */,
+                typeResult: {
+                    type: usage.setType?.type ?? types_1.UnknownType.create(),
+                    isIncomplete: !!usage.setType?.isIncomplete,
+                },
+            });
+        }
+        if (!(0, types_1.isFunctionOrOverloaded)(accessMemberType)) {
+            if ((0, types_1.isAnyOrUnknown)(accessMemberType)) {
+                return { type: accessMemberType };
+            }
+            // TODO - emit an error for this condition.
+            return undefined;
+        }
+        const callResult = validateCallArgs(errorNode, argList, { type: accessMemberType }, 
+        /* constraints */ undefined, 
+        /* skipUnknownArgCheck */ true, 
+        /* inferenceContext */ undefined);
+        let isAsymmetricAccessor = false;
+        if (usage.method === 'set') {
+            isAsymmetricAccessor = isClassWithAsymmetricAttributeAccessor(classType);
+        }
+        return {
+            type: callResult.returnType ?? types_1.UnknownType.create(),
+            typeErrors: callResult.argumentErrors,
+            isAsymmetricAccessor,
+        };
+    }
+    function synthesizeTypeAliasPlaceholder(nameNode, isTypeAliasType = false) {
+        const placeholder = types_1.TypeVarType.createInstantiable(`__type_alias_${nameNode.d.value}`);
+        placeholder.shared.isSynthesized = true;
+        const typeVarScopeId = getScopeIdForNode(nameNode);
+        const fileInfo = nodeInfo.getFileInfo(nameNode);
+        placeholder.shared.recursiveAlias = {
+            name: nameNode.d.value,
+            fullName: ParseTreeUtils.getClassFullName(nameNode, fileInfo.moduleName, nameNode.d.value),
+            moduleName: fileInfo.moduleName,
+            fileUri: fileInfo.fileUri,
+            typeVarScopeId,
+            isTypeAliasType,
+            typeParams: undefined,
+            computedVariance: undefined,
+        };
+        placeholder.priv.scopeId = typeVarScopeId;
+        return placeholder;
+    }
+    function getAliasedSymbolTypeForName(node, name) {
+        const symbolWithScope = lookUpSymbolRecursive(node, name, /* honorCodeFlow */ true);
+        if (!symbolWithScope) {
+            return undefined;
+        }
+        // Normally there will be at most one decl associated with the import node, but
+        // there can be multiple in the case of the "from .X import X" statement. In such
+        // case, we want to choose the last declaration.
+        const filteredDecls = symbolWithScope.symbol
+            .getDeclarations()
+            .filter((decl) => ParseTreeUtils.isNodeContainedWithin(node, decl.node) && decl.type === 8 /* DeclarationType.Alias */);
+        let aliasDecl = filteredDecls.length > 0 ? filteredDecls[filteredDecls.length - 1] : undefined;
+        // If we didn't find an exact match, look for any alias associated with
+        // this symbol. In cases where we have multiple ImportAs nodes that share
+        // the same first-part name (e.g. "import asyncio" and "import asyncio.tasks"),
+        // we may not find the declaration associated with this node.
+        if (!aliasDecl) {
+            aliasDecl = symbolWithScope.symbol.getDeclarations().find((decl) => decl.type === 8 /* DeclarationType.Alias */);
+        }
+        if (!aliasDecl) {
+            return undefined;
+        }
+        (0, debug_1.assert)(aliasDecl.type === 8 /* DeclarationType.Alias */);
+        const fileInfo = nodeInfo.getFileInfo(node);
+        // Try to resolve the alias while honoring external visibility.
+        const resolvedAliasInfo = resolveAliasDeclarationWithInfo(aliasDecl, /* resolveLocalNames */ true, {
+            allowExternallyHiddenAccess: fileInfo.isStubFile,
+        });
+        if (!resolvedAliasInfo) {
+            return undefined;
+        }
+        if (!resolvedAliasInfo.declaration) {
+            return evaluatorOptions.evaluateUnknownImportsAsAny ? types_1.AnyType.create() : types_1.UnknownType.create();
+        }
+        if (node.nodeType === 26 /* ParseNodeType.ImportFromAs */) {
+            if (resolvedAliasInfo.isPrivate) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportPrivateUsage, localize_1.LocMessage.privateUsedOutsideOfModule().format({
+                    name: node.d.name.d.value,
+                }), node.d.name);
+            }
+            if (resolvedAliasInfo.privatePyTypedImporter) {
+                const diag = new diagnostic_1.DiagnosticAddendum();
+                if (resolvedAliasInfo.privatePyTypedImported) {
+                    diag.addMessage(localize_1.LocAddendum.privateImportFromPyTypedSource().format({
+                        module: resolvedAliasInfo.privatePyTypedImported,
+                    }));
+                }
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportPrivateImportUsage, localize_1.LocMessage.privateImportFromPyTypedModule().format({
+                    name: node.d.name.d.value,
+                    module: resolvedAliasInfo.privatePyTypedImporter,
+                }) + diag.getString(), node.d.name);
+            }
+        }
+        return getInferredTypeOfDeclaration(symbolWithScope.symbol, aliasDecl);
+    }
+    function lookUpSymbolRecursive(node, name, honorCodeFlow, preferGlobalScope = false) {
+        const scopeNodeInfo = ParseTreeUtils.getEvaluationScopeNode(node, nodeInfo);
+        const scope = nodeInfo.getScope(scopeNodeInfo.node);
+        let symbolWithScope = scope?.lookUpSymbolRecursive(name, {
+            useProxyScope: !!scopeNodeInfo.useProxyScope,
+            useChainedModuleLevelScopes: !!scopeNodeInfo.useChainedModuleLevelScopes,
+        });
+        const scopeType = scope?.type ?? 4 /* ScopeType.Module */;
+        // Functions and list comprehensions don't allow access to implicitly
+        // aliased symbols in outer scopes if they haven't yet been assigned
+        // within the local scope.
+        let scopeTypeHonorsCodeFlow = scopeType !== 2 /* ScopeType.Function */ && scopeType !== 1 /* ScopeType.Comprehension */;
+        // Type parameter scopes don't honor code flow.
+        if (symbolWithScope?.scope.type === 0 /* ScopeType.TypeParameter */) {
+            scopeTypeHonorsCodeFlow = false;
+        }
+        if (symbolWithScope && honorCodeFlow && scopeTypeHonorsCodeFlow) {
+            // Filter the declarations based on flow reachability.
+            const reachableDecl = symbolWithScope.symbol.getDeclarations().find((decl) => {
+                if (decl.type !== 8 /* DeclarationType.Alias */ && decl.type !== 0 /* DeclarationType.Intrinsic */) {
+                    // Determine if the declaration is in the same execution scope as the "usageNode" node.
+                    let usageScopeNode = ParseTreeUtils.getExecutionScopeNode(node, nodeInfo);
+                    const declNode = decl.type === 6 /* DeclarationType.Class */ ||
+                        decl.type === 5 /* DeclarationType.Function */ ||
+                        decl.type === 4 /* DeclarationType.TypeAlias */
+                        ? decl.node.d.name
+                        : decl.node;
+                    const declScopeNode = ParseTreeUtils.getExecutionScopeNode(declNode, nodeInfo);
+                    // If this is a type parameter scope, it will be a proxy for its
+                    // containing scope, so we need to use that instead.
+                    const usageScope = nodeInfo.getScope(usageScopeNode);
+                    if (usageScope?.proxy) {
+                        const typeParamScope = nodeInfo.getScope(usageScopeNode);
+                        if (!typeParamScope?.symbolTable.has(name) && usageScopeNode.parent) {
+                            usageScopeNode = ParseTreeUtils.getExecutionScopeNode(usageScopeNode.parent, nodeInfo);
+                        }
+                    }
+                    if (usageScopeNode === declScopeNode) {
+                        if (!isFlowPathBetweenNodes(declNode, node)) {
+                            // If there was no control flow path from the usage back
+                            // to the source, see if the usage node is reachable by
+                            // any path.
+                            const flowNode = nodeInfo.getFlowNode(node);
+                            const isReachable = flowNode &&
+                                codeFlowEngine.getFlowNodeReachability(flowNode, 
+                                /* sourceFlowNode */ undefined, 
+                                /* ignoreNoReturn */ true) === typeEvaluatorTypes_1.Reachability.Reachable;
+                            return !isReachable;
+                        }
+                    }
+                }
+                return true;
+            });
+            // If none of the declarations are reachable from the current node,
+            // search for the symbol in outer scopes.
+            if (!reachableDecl) {
+                if (symbolWithScope.scope.type !== 2 /* ScopeType.Function */) {
+                    let nextScopeToSearch = symbolWithScope.scope.parent;
+                    const isOutsideCallerModule = symbolWithScope.isOutsideCallerModule || symbolWithScope.scope.type === 4 /* ScopeType.Module */;
+                    let isBeyondExecutionScope = symbolWithScope.isBeyondExecutionScope || symbolWithScope.scope.isIndependentlyExecutable();
+                    if (symbolWithScope.scope.type === 3 /* ScopeType.Class */) {
+                        // There is an odd documented behavior for classes in that
+                        // symbol resolution skips to the global scope rather than
+                        // the next scope in the chain.
+                        const globalScopeResult = symbolWithScope.scope.getGlobalScope();
+                        nextScopeToSearch = globalScopeResult.scope;
+                        if (globalScopeResult.isBeyondExecutionScope) {
+                            isBeyondExecutionScope = true;
+                        }
+                    }
+                    if (nextScopeToSearch) {
+                        symbolWithScope = nextScopeToSearch.lookUpSymbolRecursive(name, {
+                            isOutsideCallerModule,
+                            isBeyondExecutionScope,
+                        });
+                    }
+                    else {
+                        symbolWithScope = undefined;
+                    }
+                }
+                else {
+                    symbolWithScope = undefined;
+                }
+            }
+        }
+        // PEP 563 indicates that if a forward reference can be resolved in the module
+        // scope (or, by implication, in the builtins scope), it should prefer that
+        // resolution over local resolutions. This doesn't apply to a PEP 695 "type"
+        // statement's target, which binds synchronously in the scope where it appears
+        // (including a class scope) rather than being deferred like other annotations.
+        const isTypeAliasStatementTarget = symbolWithScope?.symbol
+            .getDeclarations()
+            .some((decl) => decl.type === 4 /* DeclarationType.TypeAlias */);
+        if (symbolWithScope && preferGlobalScope && !isTypeAliasStatementTarget) {
+            let curSymbolWithScope = symbolWithScope;
+            while (curSymbolWithScope.scope.type !== 4 /* ScopeType.Module */ &&
+                curSymbolWithScope.scope.type !== 5 /* ScopeType.Builtin */ &&
+                curSymbolWithScope.scope.type !== 0 /* ScopeType.TypeParameter */ &&
+                curSymbolWithScope.scope.parent) {
+                curSymbolWithScope = curSymbolWithScope.scope.parent.lookUpSymbolRecursive(name, {
+                    isOutsideCallerModule: curSymbolWithScope.isOutsideCallerModule,
+                    isBeyondExecutionScope: curSymbolWithScope.isBeyondExecutionScope ||
+                        curSymbolWithScope.scope.isIndependentlyExecutable(),
+                });
+                if (!curSymbolWithScope) {
+                    break;
+                }
+            }
+            if (curSymbolWithScope?.scope.type === 4 /* ScopeType.Module */ ||
+                curSymbolWithScope?.scope.type === 5 /* ScopeType.Builtin */) {
+                symbolWithScope = curSymbolWithScope;
+            }
+        }
+        return symbolWithScope;
+    }
+    function getDeclarationFromKeywordParam(type, paramName) {
+        if ((0, types_1.isFunction)(type)) {
+            if (type.shared.declaration) {
+                const functionDecl = type.shared.declaration;
+                if (functionDecl.type === 5 /* DeclarationType.Function */) {
+                    const functionNode = functionDecl.node;
+                    const functionScope = nodeInfo.getScope(functionNode);
+                    if (functionScope) {
+                        const paramSymbol = functionScope.lookUpSymbol(paramName);
+                        if (paramSymbol) {
+                            return paramSymbol.getDeclarations().find((decl) => decl.type === 2 /* DeclarationType.Param */);
+                        }
+                        const parameterDetails = (0, parameterUtils_1.getParamListDetails)(type);
+                        if (parameterDetails.unpackedKwargsTypedDictType) {
+                            const lookupResults = (0, typeUtils_1.lookUpClassMember)(parameterDetails.unpackedKwargsTypedDictType, paramName);
+                            if (lookupResults) {
+                                return lookupResults.symbol
+                                    .getDeclarations()
+                                    .find((decl) => decl.type === 1 /* DeclarationType.Variable */);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    function getAliasFromImport(node) {
+        if (node.parent &&
+            node.parent.nodeType === 26 /* ParseNodeType.ImportFromAs */ &&
+            node.parent.d.alias &&
+            node === node.parent.d.name) {
+            return node.parent.d.alias;
+        }
+        return undefined;
+    }
+    function getDeclInfoForStringNode(node) {
+        const decls = [];
+        const synthesizedTypes = [];
+        const expectedType = getExpectedType(node)?.type;
+        if (expectedType) {
+            (0, typeUtils_1.doForEachSubtype)(expectedType, (subtype) => {
+                // If the expected type is a TypedDict then the node is either a key expression
+                // or a single entry in a set. We then need to check that the value of the node
+                // is a valid entry in the TypedDict to avoid resolving declarations for
+                // synthesized symbols such as 'get'.
+                if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isTypedDictClass(subtype)) {
+                    const entry = subtype.shared.typedDictEntries?.knownItems.get(node.d.value);
+                    if (entry) {
+                        const symbol = (0, typeUtils_1.lookUpObjectMember)(subtype, node.d.value)?.symbol;
+                        if (symbol) {
+                            _addSymbolDeclInfo(symbol, decls, synthesizedTypes);
+                        }
+                    }
+                }
+            });
+        }
+        return decls.length === 0 ? undefined : { decls, synthesizedTypes };
+    }
+    function getDeclInfoForNameNode(node, skipUnreachableCode = true) {
+        if (skipUnreachableCode && nodeInfo.isCodeUnreachable(node)) {
+            return undefined;
+        }
+        const decls = [];
+        const synthesizedTypes = [];
+        // If the node is part of a "from X import Y as Z" statement and the node
+        // is the "Y" (non-aliased) name, we need to look up the alias symbol
+        // since the non-aliased name is not in the symbol table.
+        const alias = getAliasFromImport(node);
+        if (alias) {
+            const scope = getScopeForNode(node);
+            if (scope) {
+                // Look up the alias symbol.
+                const symbolInScope = scope.lookUpSymbolRecursive(alias.d.value);
+                if (symbolInScope) {
+                    // The alias could have more decls that don't refer to this import. Filter
+                    // out the one(s) that specifically associated with this import statement.
+                    const declsForThisImport = symbolInScope.symbol.getDeclarations().filter((decl) => {
+                        return decl.type === 8 /* DeclarationType.Alias */ && decl.node === node.parent;
+                    });
+                    (0, collectionUtils_1.appendArray)(decls, (0, declarationUtils_1.getDeclarationsWithUsesLocalNameRemoved)(declsForThisImport));
+                }
+            }
+        }
+        else if (node.parent &&
+            node.parent.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
+            node === node.parent.d.member) {
+            let baseType = getType(node.parent.d.leftExpr);
+            if (baseType) {
+                baseType = makeTopLevelTypeVarsConcrete(baseType);
+                const memberName = node.parent.d.member.d.value;
+                (0, typeUtils_1.doForEachSubtype)(baseType, (subtype) => {
+                    let symbol;
+                    subtype = makeTopLevelTypeVarsConcrete(subtype);
+                    if ((0, types_1.isInstantiableClass)(subtype)) {
+                        // Try to find a member that has a declared type. If so, that
+                        // overrides any inferred types.
+                        let member = (0, typeUtils_1.lookUpClassMember)(subtype, memberName, 64 /* MemberAccessFlags.DeclaredTypesOnly */);
+                        if (!member) {
+                            member = (0, typeUtils_1.lookUpClassMember)(subtype, memberName);
+                        }
+                        if (!member) {
+                            const metaclass = subtype.shared.effectiveMetaclass;
+                            if (metaclass && (0, types_1.isInstantiableClass)(metaclass)) {
+                                member = (0, typeUtils_1.lookUpClassMember)(metaclass, memberName);
+                            }
+                        }
+                        if (member) {
+                            symbol = member.symbol;
+                        }
+                    }
+                    else if ((0, types_1.isClassInstance)(subtype)) {
+                        // Try to find a member that has a declared type. If so, that
+                        // overrides any inferred types.
+                        let member = (0, typeUtils_1.lookUpObjectMember)(subtype, memberName, 64 /* MemberAccessFlags.DeclaredTypesOnly */);
+                        if (!member) {
+                            member = (0, typeUtils_1.lookUpObjectMember)(subtype, memberName);
+                        }
+                        if (member) {
+                            symbol = member.symbol;
+                        }
+                    }
+                    else if ((0, types_1.isModule)(subtype)) {
+                        symbol = types_1.ModuleType.getField(subtype, memberName);
+                    }
+                    if (symbol) {
+                        // By default, report only the declarations that have type annotations.
+                        // If there are none, then report all of the unannotated declarations,
+                        // which includes every assignment of that symbol.
+                        _addSymbolDeclInfo(symbol, decls, synthesizedTypes, /* preferTypedDeclarations */ true);
+                    }
+                });
+            }
+        }
+        else if (node.parent && node.parent.nodeType === 37 /* ParseNodeType.ModuleName */) {
+            const namePartIndex = node.parent.d.nameParts.findIndex((part) => part === node);
+            const importInfo = nodeInfo.getImportInfo(node.parent);
+            if (namePartIndex >= 0 &&
+                importInfo &&
+                !importInfo.isNativeLib &&
+                namePartIndex < importInfo.resolvedUris.length) {
+                if (importInfo.resolvedUris[namePartIndex]) {
+                    evaluateTypesForStatement(node);
+                    // Synthesize an alias declaration for this name part. The only
+                    // time this case is used is for IDE services such as
+                    // the find all references, hover provider and etc.
+                    decls.push((0, declarationUtils_1.synthesizeAliasDeclaration)(importInfo.resolvedUris[namePartIndex]));
+                }
+            }
+        }
+        else if (node.parent && node.parent.nodeType === 1 /* ParseNodeType.Argument */ && node === node.parent.d.name) {
+            // The target node is the name in a keyword argument. We need to determine whether
+            // the corresponding keyword parameter can be determined from the context.
+            const argNode = node.parent;
+            const paramName = node.d.value;
+            if (argNode.parent?.nodeType === 9 /* ParseNodeType.Call */) {
+                const baseType = getType(argNode.parent.d.leftExpr);
+                if (baseType) {
+                    if (_tryAddPartialKeywordParamDecls(baseType, argNode.parent, paramName, decls)) {
+                        // functools.partial keyword args are resolved against the wrapped callable.
+                    }
+                    else if ((0, types_1.isFunction)(baseType) && baseType.shared.declaration) {
+                        const paramDecl = getDeclarationFromKeywordParam(baseType, paramName);
+                        if (paramDecl) {
+                            decls.push(paramDecl);
+                        }
+                    }
+                    else if ((0, types_1.isOverloaded)(baseType)) {
+                        types_1.OverloadedType.getOverloads(baseType).forEach((f) => {
+                            const paramDecl = getDeclarationFromKeywordParam(f, paramName);
+                            if (paramDecl) {
+                                decls.push(paramDecl);
+                            }
+                        });
+                    }
+                    else if ((0, types_1.isInstantiableClass)(baseType)) {
+                        const initMethodType = (0, constructors_1.getBoundInitMethod)(context, argNode.parent.d.leftExpr, types_1.ClassType.cloneAsInstance(baseType))?.type;
+                        if (initMethodType && (0, types_1.isFunction)(initMethodType)) {
+                            const paramDecl = getDeclarationFromKeywordParam(initMethodType, paramName);
+                            if (paramDecl) {
+                                decls.push(paramDecl);
+                            }
+                            else if (_shouldFallBackToClassEntryForKeywordArg(baseType, paramName)) {
+                                _addClassEntryDeclsForKeywordArgIfPresent(baseType, paramName, decls, synthesizedTypes);
+                            }
+                        }
+                        else if (_shouldFallBackToClassEntryForKeywordArg(baseType, paramName)) {
+                            // Some synthesized callables (notably TypedDict "constructors") don't have a
+                            // meaningful __init__ signature we can map keyword arguments to. In these cases,
+                            // treat the keyword as referring to the class entry so IDE features like
+                            // go-to-definition and rename can bind to the field declaration.
+                            _addClassEntryDeclsForKeywordArgIfPresent(baseType, paramName, decls, synthesizedTypes);
+                        }
+                    }
+                }
+            }
+            else if (argNode.parent?.nodeType === 10 /* ParseNodeType.Class */) {
+                const classTypeResult = getTypeOfClass(argNode.parent);
+                // Validate the init subclass args for this class so we can properly
+                // evaluate its custom keyword parameters.
+                if (classTypeResult) {
+                    validateInitSubclassArgs(argNode.parent, classTypeResult.classType);
+                }
+            }
+        }
+        else if (node.parent &&
+            node.parent.nodeType === 74 /* ParseNodeType.PatternClassArgument */ &&
+            node === node.parent.d.name &&
+            node.parent.parent?.nodeType === 68 /* ParseNodeType.PatternClass */) {
+            // The target node is the keyword name in a class pattern argument
+            // (e.g. `case Foo(prop=...)`). Map it to the corresponding class member
+            // declaration so that find-all-references and rename bind to the attribute.
+            // Only the keyword (left of `=`) is handled here; the capture target on the
+            // right (e.g. the second `prop` in `case Foo(prop=prop)`) is a separate local
+            // binding that is resolved through the normal name-lookup path.
+            const memberName = node.d.value;
+            let classType = getType(node.parent.parent.d.className);
+            if (classType) {
+                classType = makeTopLevelTypeVarsConcrete(classType);
+                (0, typeUtils_1.doForEachSubtype)(classType, (subtype) => {
+                    subtype = makeTopLevelTypeVarsConcrete(subtype);
+                    // The class name in a class pattern usually evaluates to an instantiable class,
+                    // but analysis can still yield Unknown/Any (e.g. an unresolved class name), so
+                    // the isInstantiableClass gate skips those subtypes rather than assuming
+                    // every subtype is a class.
+                    if ((0, types_1.isInstantiableClass)(subtype)) {
+                        // Try to find a member that has a declared type. If so, that
+                        // overrides any inferred types.
+                        let member = (0, typeUtils_1.lookUpClassMember)(subtype, memberName, 64 /* MemberAccessFlags.DeclaredTypesOnly */);
+                        if (!member) {
+                            member = (0, typeUtils_1.lookUpClassMember)(subtype, memberName);
+                        }
+                        if (member) {
+                            _addSymbolDeclInfo(member.symbol, decls, synthesizedTypes, 
+                            /* preferTypedDeclarations */ true);
+                        }
+                    }
+                });
+            }
+        }
+        else {
+            const fileInfo = nodeInfo.getFileInfo(node);
+            // Determine if this node is within a quoted type annotation.
+            const isWithinTypeAnnotation = ParseTreeUtils.isWithinTypeAnnotation(node, !(0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(nodeInfo.getFileInfo(node)), nodeInfo);
+            // Determine if this is part of a "type" statement.
+            const isWithinTypeAliasStatement = !!ParseTreeUtils.getParentNodeOfType(node, 77 /* ParseNodeType.TypeAlias */);
+            const allowForwardReferences = isWithinTypeAnnotation || isWithinTypeAliasStatement || fileInfo.isStubFile;
+            const symbolWithScope = lookUpSymbolRecursive(node, node.d.value, !allowForwardReferences, isWithinTypeAnnotation);
+            if (symbolWithScope) {
+                _addSymbolDeclInfo(symbolWithScope.symbol, decls, synthesizedTypes);
+            }
+        }
+        return { decls, synthesizedTypes };
+    }
+    function includesVariableTypeDecl(decls) {
+        return decls.some((decl) => {
+            if (decl.type === 1 /* DeclarationType.Variable */) {
+                // Exempt typing.pyi and typingExtensions.pyi, which use variables to
+                // define some special forms.
+                const fileInfo = nodeInfo.getFileInfo(decl.node);
+                if (!fileInfo.isTypingStubFile && !fileInfo.isTypingExtensionsStubFile) {
+                    return true;
+                }
+            }
+            if (decl.type === 2 /* DeclarationType.Param */) {
+                return true;
+            }
+            return false;
+        });
+    }
+    function getDeclaredReturnType(node) {
+        const functionTypeInfo = getTypeOfFunction(node);
+        const returnType = functionTypeInfo?.functionType.shared.declaredReturnType;
+        if (!returnType) {
+            return undefined;
+        }
+        if (types_1.FunctionType.isGenerator(functionTypeInfo.functionType)) {
+            return (0, typeUtils_1.getDeclaredGeneratorReturnType)(functionTypeInfo.functionType);
+        }
+        return returnType;
+    }
+    function getCallbackProtocolType(objType, recursionCount = 0) {
+        if (!(0, types_1.isClassInstance)(objType) || !types_1.ClassType.isProtocolClass(objType)) {
+            return undefined;
+        }
+        // Make sure that the protocol class doesn't define any fields that
+        // a normal function wouldn't be compatible with.
+        for (const mroClass of objType.shared.mro) {
+            if ((0, types_1.isClass)(mroClass) && types_1.ClassType.isProtocolClass(mroClass)) {
+                for (const field of types_1.ClassType.getSymbolTable(mroClass)) {
+                    const fieldName = field[0];
+                    const fieldSymbol = field[1];
+                    // We're expecting a __call__ method. We will also ignore a
+                    // __slots__ definition, which is (by convention) ignored for
+                    // protocol matching.
+                    if (fieldName === '__call__' || fieldName === '__slots__') {
+                        continue;
+                    }
+                    if (fieldSymbol.isIgnoredForProtocolMatch()) {
+                        continue;
+                    }
+                    let fieldIsPartOfFunction = false;
+                    if (context.prefetched?.functionClass && (0, types_1.isClass)(context.prefetched.functionClass)) {
+                        if (types_1.ClassType.getSymbolTable(context.prefetched.functionClass).has(field[0])) {
+                            fieldIsPartOfFunction = true;
+                        }
+                    }
+                    if (!fieldIsPartOfFunction) {
+                        return undefined;
+                    }
+                }
+            }
+        }
+        const callType = getBoundMagicMethod(objType, '__call__', 
+        /* selfType */ undefined, 
+        /* errorNode */ undefined, 
+        /* diag */ undefined, recursionCount);
+        if (!callType) {
+            return undefined;
+        }
+        return (0, typeUtils_1.makeFunctionTypeVarsBound)(callType);
+    }
+    function getAbstractSymbols(classType) {
+        const symbolTable = new Map();
+        types_1.ClassType.getReverseMro(classType).forEach((mroClass) => {
+            if ((0, types_1.isInstantiableClass)(mroClass)) {
+                // See if this class is introducing a new abstract symbol that has not been
+                // introduced previously or if it is overriding an abstract symbol with
+                // a non-abstract one.
+                types_1.ClassType.getSymbolTable(mroClass).forEach((symbol, symbolName) => {
+                    const abstractSymbolInfo = getAbstractSymbolInfo(mroClass, symbolName);
+                    if (abstractSymbolInfo) {
+                        symbolTable.set(symbolName, abstractSymbolInfo);
+                    }
+                    else {
+                        symbolTable.delete(symbolName);
+                    }
+                });
+            }
+        });
+        // Create a final list of symbols that are abstract.
+        const symbolList = [];
+        symbolTable.forEach((method) => {
+            symbolList.push(method);
+        });
+        return symbolList;
+    }
+    function bindFunctionToClassOrObject(baseType, memberType, memberClass, treatConstructorAsClassMethod = false, selfType, diag, recursionCount = 0) {
+        return (0, typeUtils_1.mapSignatures)(memberType, (functionType) => {
+            // If the caller specified no base type, always strip the
+            // first parameter. This is used in cases like constructors.
+            if (!baseType) {
+                return types_1.FunctionType.clone(functionType, /* stripFirstParam */ true);
+            }
+            // If the first parameter was already stripped, it has already been
+            // bound. Don't attempt to rebind.
+            if (functionType.priv.strippedFirstParamType) {
+                return functionType;
+            }
+            if (types_1.FunctionType.isInstanceMethod(functionType) && !treatConstructorAsClassMethod) {
+                // If the baseType is a metaclass, don't specialize the function.
+                if ((0, typeUtils_1.isInstantiableMetaclass)(baseType)) {
+                    return functionType;
+                }
+                const baseObj = (0, types_1.isClassInstance)(baseType)
+                    ? baseType
+                    : types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeWithDefaultTypeArgs)(baseType));
+                let stripFirstParam = false;
+                if ((0, types_1.isClassInstance)(baseType)) {
+                    stripFirstParam = true;
+                }
+                else if (memberClass && (0, typeUtils_1.isInstantiableMetaclass)(memberClass)) {
+                    stripFirstParam = true;
+                }
+                return partiallySpecializeBoundMethod(baseType, functionType, diag, recursionCount, selfType ?? baseObj, stripFirstParam);
+            }
+            if (types_1.FunctionType.isClassMethod(functionType) || treatConstructorAsClassMethod) {
+                const baseClass = (0, types_1.isInstantiableClass)(baseType) ? baseType : types_1.ClassType.cloneAsInstantiable(baseType);
+                const clsType = selfType ? (0, typeUtils_1.convertToInstantiable)(selfType) : undefined;
+                return partiallySpecializeBoundMethod(baseClass, functionType, diag, recursionCount, clsType ?? baseClass, 
+                /* stripFirstParam */ true);
+            }
+            if (types_1.FunctionType.isStaticMethod(functionType)) {
+                const baseClass = (0, types_1.isInstantiableClass)(baseType) ? baseType : types_1.ClassType.cloneAsInstantiable(baseType);
+                return partiallySpecializeBoundMethod(baseClass, functionType, diag, recursionCount, 
+                /* firstParamType */ undefined, 
+                /* stripFirstParam */ false);
+            }
+            return functionType;
+        });
+    }
+    function isExplicitTypeAliasDeclaration(decl) {
+        if (decl.type !== 1 /* DeclarationType.Variable */ || !decl.typeAnnotationNode) {
+            return false;
+        }
+        if (decl.typeAnnotationNode.nodeType !== 38 /* ParseNodeType.Name */ &&
+            decl.typeAnnotationNode.nodeType !== 35 /* ParseNodeType.MemberAccess */ &&
+            decl.typeAnnotationNode.nodeType !== 48 /* ParseNodeType.StringList */) {
+            return false;
+        }
+        const type = getTypeOfAnnotation(decl.typeAnnotationNode, { varTypeAnnotation: true, allowClassVar: true });
+        return (0, types_1.isClassInstance)(type) && types_1.ClassType.isBuiltIn(type, 'TypeAlias');
+    }
+    function isPossibleTypeAliasDeclaration(decl) {
+        if (decl.type !== 1 /* DeclarationType.Variable */ || !decl.typeAliasName || decl.typeAnnotationNode) {
+            return false;
+        }
+        if (decl.node.parent?.nodeType !== 3 /* ParseNodeType.Assignment */) {
+            return false;
+        }
+        // Perform a sanity check on the RHS expression. Some expression
+        // forms should never be considered legitimate for type aliases.
+        return isLegalTypeAliasExpressionForm(decl.node.parent.d.rightExpr, /* allowStrLiteral */ false);
+    }
+    function isLegalImplicitTypeAliasType(type) {
+        // We explicitly exclude "..." and "Unknown".
+        if ((0, typeUtils_1.isEllipsisType)(type)) {
+            return false;
+        }
+        if ((0, types_1.isUnknown)(type)) {
+            // If this is a union type, we'll assume that it was meant as a type
+            // alias even though all of the union subtypes are Unknown.
+            if (type.props?.specialForm && types_1.ClassType.isBuiltIn(type.props.specialForm, 'UnionType')) {
+                return true;
+            }
+            return false;
+        }
+        // Look at the subtypes within the union. If any of them are not
+        // instantiable (other than "None" which is special-cased), it is
+        // not a legal type alias type.
+        let isLegal = true;
+        (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+            if (!types_1.TypeBase.isInstantiable(subtype) && !(0, typeUtils_1.isNoneInstance)(subtype)) {
+                isLegal = false;
+            }
+        });
+        return isLegal;
+    }
+    function isClassWithAsymmetricAttributeAccessor(classType) {
+        // If the value has already been cached in this type, return the cached value.
+        if (classType.priv.isAsymmetricAttributeAccessor !== undefined) {
+            return classType.priv.isAsymmetricAttributeAccessor;
+        }
+        let isAsymmetric = false;
+        const getterSymbolResult = (0, typeUtils_1.lookUpClassMember)(classType, '__getattr__', 2 /* MemberAccessFlags.SkipBaseClasses */);
+        const setterSymbolResult = (0, typeUtils_1.lookUpClassMember)(classType, '__setattr__', 2 /* MemberAccessFlags.SkipBaseClasses */);
+        if (!getterSymbolResult || !setterSymbolResult) {
+            isAsymmetric = false;
+        }
+        else {
+            const getterType = getEffectiveTypeOfSymbol(getterSymbolResult.symbol);
+            const setterType = getEffectiveTypeOfSymbol(setterSymbolResult.symbol);
+            // If either the setter or getter is an overload (or some other non-function type),
+            // conservatively assume that it's not asymmetric.
+            if ((0, types_1.isFunction)(getterType) && (0, types_1.isFunction)(setterType)) {
+                // If there's no declared return type on the getter, assume it's symmetric.
+                if (setterType.shared.parameters.length >= 3 && getterType.shared.declaredReturnType) {
+                    const setterValueType = types_1.FunctionType.getParamType(setterType, 2);
+                    const getterReturnType = types_1.FunctionType.getEffectiveReturnType(getterType) ?? types_1.UnknownType.create();
+                    if (!(0, types_1.isTypeSame)(setterValueType, getterReturnType)) {
+                        isAsymmetric = true;
+                    }
+                }
+            }
+        }
+        // Cache the value for next time.
+        classType.priv.isAsymmetricAttributeAccessor = isAsymmetric;
+        return isAsymmetric;
+    }
+    return {
+        pushSymbolResolution,
+        popSymbolResolution,
+        setSymbolResolutionPartialType,
+        getSymbolResolutionPartialType,
+        isDeclaredTypeAlias,
+        validateSymbolIsTypeExpression,
+        bindMethodForMemberAccess,
+        isAsymmetricDescriptorClass,
+        applyAttributeAccessOverride,
+        synthesizeTypeAliasPlaceholder,
+        getAliasedSymbolTypeForName,
+        lookUpSymbolRecursive,
+        getDeclInfoForStringNode,
+        getDeclInfoForNameNode,
+        includesVariableTypeDecl,
+        getDeclaredReturnType,
+        getCallbackProtocolType,
+        getAbstractSymbols,
+        bindFunctionToClassOrObject,
+        isExplicitTypeAliasDeclaration,
+        isPossibleTypeAliasDeclaration,
+        isLegalImplicitTypeAliasType,
+        getTypeOfMember,
+        getTypeOfMemberInternal,
+        getIndexOfSymbolResolution,
+        getDeclarationFromKeywordParam,
+        getAliasFromImport,
+    };
+}
+//# sourceMappingURL=memberResolution.js.map