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

package/dist/analyzer/typeEvaluator/evaluatorCore.js

@@ -0,0 +1,1126 @@
+"use strict";
+/*
+ * evaluatorCore.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * evaluatorCore 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.createEvaluatorCore = createEvaluatorCore;
+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 constraintSolution_1 = require("../constraintSolution");
+const constraintSolver_1 = require("../constraintSolver");
+const constraintTracker_1 = require("../constraintTracker");
+const constructors_1 = require("../constructors");
+const decorators_1 = require("../decorators");
+const ParseTreeUtils = __importStar(require("../parseTreeUtils"));
+const ScopeUtils = __importStar(require("../scopeUtils"));
+const symbolNameUtils_1 = require("../symbolNameUtils");
+const symbolUtils_1 = require("../symbolUtils");
+const tuples_1 = require("../tuples");
+const types_1 = require("../types");
+const typeUtils_1 = require("../typeUtils");
+// Shared type-expression and specialization operations not yet isolated into narrower topics.
+function createEvaluatorCore(contextDependencies) {
+    const { createSpecializedClassType, addDiagnostic, assignType, evaluatorInterface, getEffectiveTypeOfSymbol, getScopeForNode, getScopeIdForNode, getTypeOfBoundMember, getTypeOfExpression, getTypeOfExpressionExpectingType, inferReturnTypeIfNecessary, isTypeFormClass, isTypePromotionRelated, makeTopLevelTypeVarsConcrete, nodeInfo, printType, stripLiteralValue, suppressDiagnostics, validateCallArgs, } = contextDependencies;
+    function validateTypeIsInstantiable(typeResult, flags, node) {
+        // If the type is incomplete, don't log any diagnostics yet.
+        if (typeResult.isIncomplete) {
+            return;
+        }
+        if ((flags & 64 /* EvalFlags.NoTypeVarTuple */) !== 0) {
+            if ((0, types_1.isTypeVarTuple)(typeResult.type) && !typeResult.type.priv.isInUnion) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeVarTupleContext(), node);
+                typeResult.type = types_1.UnknownType.create();
+            }
+        }
+        if ((0, typeUtils_1.isEffectivelyInstantiable)(typeResult.type, { honorTypeVarBounds: true })) {
+            return;
+        }
+        // Exempt ellipses.
+        if ((0, types_1.isClassInstance)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, ['EllipsisType', 'ellipsis'])) {
+            return;
+        }
+        // Emit these errors only if we know we're evaluating a type expression.
+        if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+            const diag = new diagnostic_1.DiagnosticAddendum();
+            if ((0, types_1.isUnion)(typeResult.type)) {
+                (0, typeUtils_1.doForEachSubtype)(typeResult.type, (subtype) => {
+                    if (!(0, typeUtils_1.isEffectivelyInstantiable)(subtype, { honorTypeVarBounds: true })) {
+                        diag.addMessage(localize_1.LocAddendum.typeNotClass().format({ type: printType(subtype) }));
+                    }
+                });
+            }
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeExpectedClass().format({ type: printType(typeResult.type) }) + diag.getString(), node);
+            typeResult.type = types_1.UnknownType.create();
+        }
+        typeResult.typeErrors = true;
+    }
+    function solveAndApplyConstraints(type, constraints, applyOptions, solveOptions) {
+        const solution = (0, constraintSolver_1.solveConstraints)(evaluatorInterface, constraints, solveOptions);
+        return (0, typeUtils_1.applySolvedTypeVars)(type, solution, applyOptions);
+    }
+    function getBoundMagicMethod(classType, memberName, selfType, errorNode, diag, recursionCount = 0) {
+        const boundMethodResult = getTypeOfBoundMember(errorNode, classType, memberName, 
+        /* usage */ undefined, diag, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */, selfType, recursionCount);
+        if (!boundMethodResult || boundMethodResult.typeErrors) {
+            return undefined;
+        }
+        if ((0, types_1.isFunctionOrOverloaded)(boundMethodResult.type)) {
+            return boundMethodResult.type;
+        }
+        if ((0, types_1.isClassInstance)(boundMethodResult.type)) {
+            if (recursionCount > types_1.maxTypeRecursionCount) {
+                return undefined;
+            }
+            recursionCount++;
+            return getBoundMagicMethod(boundMethodResult.type, '__call__', 
+            /* selfType */ undefined, errorNode, diag, recursionCount);
+        }
+        if ((0, types_1.isAnyOrUnknown)(boundMethodResult.type)) {
+            return (0, typeUtils_1.getUnknownTypeForCallable)();
+        }
+        return undefined;
+    }
+    function getTypeOfAwaitable(typeResult, errorNode) {
+        if (!contextDependencies.prefetched?.awaitableClass ||
+            !(0, types_1.isInstantiableClass)(contextDependencies.prefetched.awaitableClass) ||
+            contextDependencies.prefetched.awaitableClass.shared.typeParams.length !== 1) {
+            return { type: types_1.UnknownType.create(), isIncomplete: typeResult.isIncomplete };
+        }
+        const awaitableProtocolObj = types_1.ClassType.cloneAsInstance(contextDependencies.prefetched.awaitableClass);
+        const isIncomplete = !!typeResult.isIncomplete;
+        const type = (0, typeUtils_1.mapSubtypes)(typeResult.type, (subtype) => {
+            subtype = makeTopLevelTypeVarsConcrete(subtype);
+            if ((0, types_1.isAnyOrUnknown)(subtype)) {
+                return subtype;
+            }
+            const diag = errorNode ? new diagnostic_1.DiagnosticAddendum() : undefined;
+            if ((0, types_1.isClassInstance)(subtype)) {
+                const constraints = new constraintTracker_1.ConstraintTracker();
+                if (assignType(awaitableProtocolObj, subtype, diag, constraints)) {
+                    const specializedType = solveAndApplyConstraints(awaitableProtocolObj, constraints);
+                    if ((0, types_1.isClass)(specializedType) &&
+                        specializedType.priv.typeArgs &&
+                        specializedType.priv.typeArgs.length > 0) {
+                        return specializedType.priv.typeArgs[0];
+                    }
+                    return types_1.UnknownType.create();
+                }
+            }
+            if (errorNode && !typeResult.isIncomplete) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeNotAwaitable().format({ type: printType(subtype) }) + diag?.getString(), errorNode);
+            }
+            return types_1.UnknownType.create();
+        });
+        return { type, isIncomplete };
+    }
+    function isTypeHashable(type) {
+        let isTypeHashable = true;
+        (0, typeUtils_1.doForEachSubtype)(makeTopLevelTypeVarsConcrete(type), (subtype) => {
+            if ((0, types_1.isClassInstance)(subtype)) {
+                // Assume the class is hashable.
+                let isObjectHashable = true;
+                // Have we already computed and cached the hashability?
+                if (subtype.shared.isInstanceHashable !== undefined) {
+                    isObjectHashable = subtype.shared.isInstanceHashable;
+                }
+                else {
+                    const hashMember = (0, typeUtils_1.lookUpObjectMember)(subtype, '__hash__', 4 /* MemberAccessFlags.SkipObjectBaseClass */);
+                    if (hashMember && hashMember.isTypeDeclared) {
+                        const decls = hashMember.symbol.getTypedDeclarations();
+                        const synthesizedType = hashMember.symbol.getSynthesizedType();
+                        // Handle the case where the type is synthesized (used for
+                        // dataclasses).
+                        if (synthesizedType) {
+                            isObjectHashable = !(0, typeUtils_1.isNoneInstance)(synthesizedType.type);
+                        }
+                        else {
+                            // Assume that if '__hash__' is declared as a variable, it is
+                            // not hashable. If it's declared as a function, it is. We'll
+                            // skip evaluating its full type because that's not needed in
+                            // this case.
+                            if (decls.every((decl) => decl.type === 1 /* DeclarationType.Variable */)) {
+                                isObjectHashable = false;
+                            }
+                        }
+                    }
+                    // Cache the hashability for next time.
+                    subtype.shared.isInstanceHashable = isObjectHashable;
+                }
+                if (!isObjectHashable) {
+                    isTypeHashable = false;
+                }
+            }
+        });
+        return isTypeHashable;
+    }
+    function getTypedDictClassType() {
+        return contextDependencies.prefetched?.typedDictPrivateClass &&
+            (0, types_1.isInstantiableClass)(contextDependencies.prefetched.typedDictPrivateClass)
+            ? contextDependencies.prefetched.typedDictPrivateClass
+            : undefined;
+    }
+    function getTupleClassType() {
+        return contextDependencies.prefetched?.tupleClass &&
+            (0, types_1.isInstantiableClass)(contextDependencies.prefetched.tupleClass)
+            ? contextDependencies.prefetched.tupleClass
+            : undefined;
+    }
+    function getDictClassType() {
+        return contextDependencies.prefetched?.dictClass &&
+            (0, types_1.isInstantiableClass)(contextDependencies.prefetched.dictClass)
+            ? contextDependencies.prefetched.dictClass
+            : undefined;
+    }
+    function getStrClassType() {
+        return contextDependencies.prefetched?.strClass && (0, types_1.isInstantiableClass)(contextDependencies.prefetched.strClass)
+            ? contextDependencies.prefetched.strClass
+            : undefined;
+    }
+    function getObjectType() {
+        return contextDependencies.prefetched?.objectClass
+            ? (0, typeUtils_1.convertToInstance)(contextDependencies.prefetched.objectClass)
+            : types_1.UnknownType.create();
+    }
+    function getNoneType() {
+        return contextDependencies.prefetched?.noneTypeClass
+            ? (0, typeUtils_1.convertToInstance)(contextDependencies.prefetched.noneTypeClass)
+            : types_1.UnknownType.create();
+    }
+    function getUnionClassType() {
+        return contextDependencies.prefetched?.unionTypeClass ?? types_1.UnknownType.create();
+    }
+    function getTypeClassType() {
+        if (contextDependencies.prefetched?.typeClass &&
+            (0, types_1.isInstantiableClass)(contextDependencies.prefetched.typeClass)) {
+            return contextDependencies.prefetched.typeClass;
+        }
+        return undefined;
+    }
+    function verifyRaiseExceptionType(node, allowNone) {
+        const baseExceptionType = getBuiltInType(node, 'BaseException');
+        const exceptionType = getTypeOfExpression(node).type;
+        // Validate that the argument of "raise" is an exception object or class.
+        // If it is a class, validate that the class's constructor accepts zero
+        // arguments.
+        if (exceptionType && baseExceptionType && (0, types_1.isInstantiableClass)(baseExceptionType)) {
+            const diag = new diagnostic_1.DiagnosticAddendum();
+            (0, typeUtils_1.doForEachSubtype)(exceptionType, (subtype) => {
+                const concreteSubtype = makeTopLevelTypeVarsConcrete(subtype);
+                if ((0, types_1.isAnyOrUnknown)(concreteSubtype) || (0, types_1.isNever)(concreteSubtype)) {
+                    return;
+                }
+                if (allowNone && (0, typeUtils_1.isNoneInstance)(concreteSubtype)) {
+                    return;
+                }
+                if ((0, types_1.isInstantiableClass)(concreteSubtype) && concreteSubtype.priv.literalValue === undefined) {
+                    if (!(0, typeUtils_1.derivesFromClassRecursive)(concreteSubtype, baseExceptionType, /* ignoreUnknown */ false)) {
+                        diag.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
+                            type: printType(subtype),
+                        }));
+                    }
+                    else {
+                        let callResult;
+                        suppressDiagnostics(node, () => {
+                            callResult = (0, constructors_1.validateConstructorArgs)(evaluatorInterface, node, [], concreteSubtype, 
+                            /* skipUnknownArgCheck */ false, 
+                            /* inferenceContext */ undefined);
+                        });
+                        if (callResult && callResult.argumentErrors) {
+                            diag.addMessage(localize_1.LocMessage.exceptionTypeNotInstantiable().format({
+                                type: printType(subtype),
+                            }));
+                        }
+                    }
+                }
+                else if ((0, types_1.isClassInstance)(concreteSubtype)) {
+                    if (!(0, typeUtils_1.derivesFromClassRecursive)(types_1.ClassType.cloneAsInstantiable(concreteSubtype), baseExceptionType, 
+                    /* ignoreUnknown */ false)) {
+                        diag.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
+                            type: printType(subtype),
+                        }));
+                    }
+                }
+                else {
+                    diag.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
+                        type: printType(subtype),
+                    }));
+                }
+            });
+            if (!diag.isEmpty()) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.expectedExceptionClass() + diag.getString(), node);
+            }
+        }
+    }
+    function isSymbolValidTypeExpression(type, includesVarDecl) {
+        // Verify that the name does not refer to a (non type alias) variable.
+        if (!includesVarDecl || type.props?.typeAliasInfo) {
+            return true;
+        }
+        if ((0, typeUtils_1.isTypeAliasPlaceholder)(type)) {
+            return true;
+        }
+        if ((0, types_1.isTypeVar)(type)) {
+            if (type.props?.specialForm || type.props?.typeAliasInfo) {
+                return true;
+            }
+        }
+        // Exempts class types that are created by calling NewType, NamedTuple, etc.
+        if ((0, types_1.isClass)(type) && !type.priv.includeSubclasses && types_1.ClassType.isValidTypeAliasClass(type)) {
+            return true;
+        }
+        if ((0, typeUtils_1.isSentinelLiteral)(type)) {
+            return true;
+        }
+        return false;
+    }
+    function convertSpecialFormToRuntimeValue(type, flags, convertModule = false) {
+        const exemptFlags = 256 /* EvalFlags.TypeExpression */ | 128 /* EvalFlags.InstantiableType */ | 33554432 /* EvalFlags.NoConvertSpecialForm */;
+        if ((flags & exemptFlags) !== 0) {
+            return type;
+        }
+        if (convertModule &&
+            (0, types_1.isModule)(type) &&
+            contextDependencies.prefetched?.moduleTypeClass &&
+            (0, types_1.isInstantiableClass)(contextDependencies.prefetched.moduleTypeClass)) {
+            return types_1.ClassType.cloneAsInstance(contextDependencies.prefetched.moduleTypeClass);
+        }
+        // Isinstance treats traditional (non-PEP 695) type aliases that are unions
+        // as tuples of classes rather than unions.
+        if ((flags & 536870912 /* EvalFlags.IsinstanceArg */) !== 0) {
+            if ((0, types_1.isUnion)(type) && type.props?.typeAliasInfo && !type.props.typeAliasInfo.shared.isTypeAliasType) {
+                return type;
+            }
+        }
+        if (!type.props?.specialForm) {
+            return type;
+        }
+        // If this is a type alias and we are not supposed to specialize it, return it as is.
+        if ((flags & 2 /* EvalFlags.NoSpecialize */) !== 0 && type.props?.typeAliasInfo) {
+            // Special-case TypeAliasType which should be converted in this case.
+            if (!types_1.ClassType.isBuiltIn(type.props.specialForm, 'TypeAliasType')) {
+                return type;
+            }
+        }
+        if (type.props?.typeForm) {
+            return types_1.TypeBase.cloneWithTypeForm(type.props.specialForm, type.props.typeForm);
+        }
+        return type.props.specialForm;
+    }
+    function reportMissingTypeArgs(node, type, flags) {
+        if ((flags & 2 /* EvalFlags.NoSpecialize */) !== 0) {
+            return type;
+        }
+        // Is this a generic class that needs to be specialized?
+        if ((0, types_1.isInstantiableClass)(type)) {
+            if ((flags & 128 /* EvalFlags.InstantiableType */) !== 0 && (flags & 512 /* EvalFlags.AllowMissingTypeArgs */) === 0) {
+                if (!type.props?.typeAliasInfo && !isTypeFormClass(type) && (0, typeUtils_1.requiresTypeArgs)(type)) {
+                    if (!type.priv.typeArgs || !type.priv.isTypeArgExplicit) {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.LocMessage.typeArgsMissingForClass().format({
+                            name: type.priv.aliasName || type.shared.name,
+                        }), node);
+                    }
+                }
+            }
+            if (!type.priv.typeArgs) {
+                type = createSpecializedClassType(type, /* typeArgs */ undefined, flags, node)?.type;
+            }
+        }
+        // Is this a generic type alias that needs to be specialized?
+        if ((flags & 128 /* EvalFlags.InstantiableType */) !== 0) {
+            type = specializeTypeAliasWithDefaults(type, node);
+        }
+        return type;
+    }
+    function specializeTypeAliasWithDefaults(type, errorNode) {
+        // Is this a type alias?
+        const aliasInfo = type.props?.typeAliasInfo;
+        if (!aliasInfo) {
+            return type;
+        }
+        // Is this a generic type alias that needs specializing?
+        if (!aliasInfo.shared.typeParams || aliasInfo.shared.typeParams.length === 0 || aliasInfo.typeArgs) {
+            return type;
+        }
+        let reportDiag = false;
+        const defaultTypeArgs = [];
+        const constraints = new constraintTracker_1.ConstraintTracker();
+        aliasInfo.shared.typeParams.forEach((param) => {
+            if (!param.shared.isDefaultExplicit) {
+                reportDiag = true;
+            }
+            let defaultType;
+            if (param.shared.isDefaultExplicit || (0, types_1.isParamSpec)(param)) {
+                defaultType = solveAndApplyConstraints(param, constraints, {
+                    replaceUnsolved: {
+                        scopeIds: [aliasInfo.shared.typeVarScopeId],
+                        tupleClassType: getTupleClassType(),
+                    },
+                });
+            }
+            else if ((0, types_1.isTypeVarTuple)(param) &&
+                contextDependencies.prefetched?.tupleClass &&
+                (0, types_1.isInstantiableClass)(contextDependencies.prefetched.tupleClass)) {
+                defaultType = (0, tuples_1.makeTupleObject)(evaluatorInterface, [{ type: types_1.UnknownType.create(), isUnbounded: true }], 
+                /* isUnpacked */ true);
+            }
+            else {
+                defaultType = types_1.UnknownType.create();
+            }
+            defaultTypeArgs.push(defaultType);
+            constraints.setBounds(param, defaultType);
+        });
+        if (reportDiag && errorNode) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.LocMessage.typeArgsMissingForAlias().format({
+                name: aliasInfo.shared.name,
+            }), errorNode);
+        }
+        type = types_1.TypeBase.cloneForTypeAlias(solveAndApplyConstraints(type, constraints, {
+            replaceUnsolved: {
+                scopeIds: [aliasInfo.shared.typeVarScopeId],
+                tupleClassType: getTupleClassType(),
+            },
+        }), { ...aliasInfo, typeArgs: defaultTypeArgs });
+        return type;
+    }
+    function buildTupleTypesList(entryTypeResults, stripLiterals, convertModule) {
+        const entryTypes = [];
+        for (const typeResult of entryTypeResults) {
+            let possibleUnpackedTuple;
+            if (typeResult.unpackedType) {
+                possibleUnpackedTuple = typeResult.unpackedType;
+            }
+            else if ((0, types_1.isUnpacked)(typeResult.type)) {
+                possibleUnpackedTuple = typeResult.type;
+            }
+            // Is this an unpacked tuple? If so, we can append the individual
+            // unpacked entries onto the new tuple. If it's not an upacked tuple
+            // but some other iterator (e.g. a List), we won't know the number of
+            // items, so we'll need to leave the Tuple open-ended.
+            if (possibleUnpackedTuple &&
+                (0, types_1.isClassInstance)(possibleUnpackedTuple) &&
+                possibleUnpackedTuple.priv.tupleTypeArgs) {
+                const typeArgs = possibleUnpackedTuple.priv.tupleTypeArgs;
+                if (!typeArgs) {
+                    entryTypes.push({ type: types_1.UnknownType.create(), isUnbounded: true });
+                }
+                else {
+                    (0, collectionUtils_1.appendArray)(entryTypes, typeArgs);
+                }
+            }
+            else if ((0, types_1.isNever)(typeResult.type) && typeResult.isIncomplete && !typeResult.unpackedType) {
+                entryTypes.push({ type: types_1.UnknownType.create(/* isIncomplete */ true), isUnbounded: false });
+            }
+            else {
+                let entryType = convertSpecialFormToRuntimeValue(typeResult.type, 0 /* EvalFlags.None */, convertModule);
+                entryType = stripLiterals ? (0, typeUtils_1.stripTypeForm)(stripLiteralValue(entryType)) : entryType;
+                entryTypes.push({ type: entryType, isUnbounded: !!typeResult.unpackedType });
+            }
+        }
+        // If there are multiple unbounded entries, combine all of them into a single
+        // unbounded entry to avoid violating the invariant that there can be at most
+        // one unbounded entry in a tuple.
+        if (entryTypes.filter((t) => t.isUnbounded).length > 1) {
+            const firstUnboundedEntryIndex = entryTypes.findIndex((t) => t.isUnbounded);
+            const removedEntries = entryTypes.splice(firstUnboundedEntryIndex);
+            entryTypes.push({ type: (0, types_1.combineTypes)(removedEntries.map((t) => t.type)), isUnbounded: true });
+        }
+        return entryTypes;
+    }
+    function convertNodeToArg(node) {
+        return {
+            argCategory: node.d.argCategory,
+            name: node.d.name,
+            valueExpression: node.d.valueExpr,
+        };
+    }
+    // Include all arguments even when the error node isn't a call, as in __init_subclass__ validation.
+    function getSpeculativeNodeForCall(errorNode) {
+        // If the error node is within an arg, expand to include the parent of the arg list.
+        const argParent = ParseTreeUtils.getParentNodeOfType(errorNode, 1 /* ParseNodeType.Argument */);
+        if (argParent?.parent) {
+            return argParent.parent;
+        }
+        // If the error node is the name in a class declaration, expand to include the class node.
+        if (errorNode.nodeType === 38 /* ParseNodeType.Name */ &&
+            errorNode.parent?.nodeType === 10 /* ParseNodeType.Class */ &&
+            errorNode.parent.d.name === errorNode) {
+            return errorNode.parent;
+        }
+        return errorNode;
+    }
+    function getAbstractSymbolInfo(classType, symbolName) {
+        const isProtocolClass = types_1.ClassType.isProtocolClass(classType);
+        const symbol = types_1.ClassType.getSymbolTable(classType).get(symbolName);
+        if (!symbol) {
+            return undefined;
+        }
+        // Ignore instance variables. Also, ignore named tuple members, which are
+        // modeled in pyright as instance variables, but their runtime implementation
+        // uses a descriptor object.
+        if (!symbol.isClassMember() && !symbol.isNamedTupleMemberMember()) {
+            return undefined;
+        }
+        const lastDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(symbol);
+        if (!lastDecl) {
+            return undefined;
+        }
+        // Handle protocol variables specially.
+        if (isProtocolClass && lastDecl.type === 1 /* DeclarationType.Variable */) {
+            // If none of the declarations involve assignments, assume it's
+            // not implemented in the protocol.
+            const allDecls = symbol.getDeclarations();
+            if (!allDecls.some((decl) => decl.type === 1 /* DeclarationType.Variable */ && !!decl.inferredTypeSource)) {
+                return { symbol, symbolName, classType, hasImplementation: false };
+            }
+        }
+        if (lastDecl.type !== 5 /* DeclarationType.Function */) {
+            return undefined;
+        }
+        let isAbstract = false;
+        const lastFunctionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, lastDecl.node, 
+        /* isInClass */ true, nodeInfo);
+        if ((lastFunctionInfo.flags & 8 /* FunctionTypeFlags.AbstractMethod */) !== 0) {
+            isAbstract = true;
+        }
+        const isStubFile = nodeInfo.getFileInfo(lastDecl.node).isStubFile;
+        // In an overloaded method, the first overload can also be marked abstract.
+        // In stub files, there is no implementation, so this is the only way to mark
+        // an overloaded method as abstract.
+        const firstDecl = symbol.getDeclarations()[0];
+        let firstFunctionInfo;
+        if (firstDecl !== lastDecl && firstDecl.type === 5 /* DeclarationType.Function */) {
+            firstFunctionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, firstDecl.node, 
+            /* isInClass */ true, nodeInfo);
+            if ((firstFunctionInfo.flags & 8 /* FunctionTypeFlags.AbstractMethod */) !== 0) {
+                isAbstract = true;
+            }
+            // If there's no implementation, assume it's unimplemented.
+            if (isProtocolClass && (lastFunctionInfo.flags & 256 /* FunctionTypeFlags.Overloaded */) !== 0) {
+                // If this is a protocol class method defined in a stub file and
+                // it's not marked abstract, assume it's not abstract and implemented.
+                if (isProtocolClass && !isAbstract && isStubFile) {
+                    return undefined;
+                }
+                return { symbol, symbolName, classType, hasImplementation: false };
+            }
+        }
+        // In a non-protocol class, if the method isn't explicitly marked abstract,
+        // then it's not abstract.
+        if (!isProtocolClass && !isAbstract) {
+            return undefined;
+        }
+        const hasImplementation = !ParseTreeUtils.isSuiteEmpty(lastDecl.node.d.suite) && !methodAlwaysRaisesNotImplemented(lastDecl);
+        // If this is a protocol class, the method isn't explicitly marked
+        // as abstract, and there is an implementation, then it's a default
+        // implementation, and it's not considered abstract. If it's in a stub
+        // file, assume it's implemented in this case.
+        if (isProtocolClass && !isAbstract) {
+            if (hasImplementation || isStubFile) {
+                return undefined;
+            }
+        }
+        return { symbol, symbolName, classType, hasImplementation };
+    }
+    function validateCallForClassInstance(errorNode, argList, expandedCallType, unexpandedCallType, constraints, skipUnknownArgCheck, inferenceContext, recursionCount) {
+        const callDiag = new diagnostic_1.DiagnosticAddendum();
+        const callMethodResult = getTypeOfBoundMember(errorNode, expandedCallType, '__call__', 
+        /* usage */ undefined, callDiag, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */, 
+        /* selfType */ undefined, recursionCount);
+        const callMethodType = callMethodResult?.type;
+        if (!callMethodType || callMethodResult.typeErrors) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.objectNotCallable().format({
+                type: printType(expandedCallType),
+            }) + callDiag.getString(), errorNode);
+            return { returnType: types_1.UnknownType.create(), argumentErrors: true };
+        }
+        const callResult = validateCallArgs(errorNode, argList, { type: callMethodType }, constraints, skipUnknownArgCheck, inferenceContext, recursionCount);
+        let returnType = callResult.returnType ?? types_1.UnknownType.create();
+        if ((0, types_1.isTypeVar)(unexpandedCallType) &&
+            types_1.TypeBase.isInstantiable(unexpandedCallType) &&
+            (0, types_1.isClass)(expandedCallType) &&
+            types_1.ClassType.isBuiltIn(expandedCallType, 'type')) {
+            // Handle the case where a type[T] is being called. We presume this
+            // will instantiate an object of type T.
+            returnType = (0, typeUtils_1.convertToInstance)(unexpandedCallType);
+        }
+        return {
+            returnType,
+            argumentErrors: callResult.argumentErrors,
+            overloadsUsedForCall: callResult.overloadsUsedForCall,
+        };
+    }
+    function adjustCallableReturnType(callNode, returnType, liveTypeVarScopes) {
+        if (!(0, types_1.isFunction)(returnType)) {
+            return returnType;
+        }
+        // What type variables are referenced in the callable return type? Do not include any live type variables.
+        const typeParams = (0, typeUtils_1.getTypeVarArgsRecursive)(returnType).filter((t) => !liveTypeVarScopes.some((scopeId) => t.priv.scopeId === scopeId));
+        // If there are no unsolved type variables, we're done. If there are
+        // unsolved type variables, rescope them to the callable.
+        if (typeParams.length === 0) {
+            return returnType;
+        }
+        inferReturnTypeIfNecessary(returnType);
+        // Create a new scope ID based on the caller's position. This
+        // will guarantee uniqueness. If another caller uses the same
+        // call and arguments, the type vars will not conflict.
+        const newScopeId = getScopeIdForNode(callNode);
+        const solution = new constraintSolution_1.ConstraintSolution();
+        const newTypeParams = typeParams.map((typeVar) => {
+            const newTypeParam = types_1.TypeVarType.cloneForScopeId(typeVar, newScopeId, typeVar.priv.scopeName, 1 /* TypeVarScopeType.Function */);
+            solution.setType(typeVar, newTypeParam);
+            return newTypeParam;
+        });
+        return (0, typeUtils_1.applySolvedTypeVars)(types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, newScopeId, 
+        /* constructorTypeVarScopeId */ undefined, newTypeParams), solution);
+    }
+    function getFunctionFullName(functionNode, moduleName, functionName) {
+        const nameParts = [functionName];
+        let curNode = functionNode;
+        // Walk the parse tree looking for classes or functions.
+        while (curNode) {
+            curNode = ParseTreeUtils.getEnclosingClassOrFunction(curNode);
+            if (curNode) {
+                nameParts.push(curNode.d.name.d.value);
+            }
+        }
+        nameParts.push(moduleName);
+        return nameParts.reverse().join('.');
+    }
+    function reportPossibleUnknownAssignment(diagLevel, rule, target, type, errorNode, ignoreEmptyContainers) {
+        // Don't bother if the feature is disabled.
+        if (diagLevel === 'none') {
+            return;
+        }
+        const nameValue = target.d.value;
+        // Sometimes variables contain an "unbound" type if they're
+        // assigned only within conditional statements. Remove this
+        // to avoid confusion.
+        const simplifiedType = (0, types_1.removeUnbound)(type);
+        if ((0, types_1.isUnknown)(simplifiedType)) {
+            addDiagnostic(rule, localize_1.LocMessage.typeUnknown().format({ name: nameValue }), errorNode);
+        }
+        else if ((0, typeUtils_1.isPartlyUnknown)(simplifiedType)) {
+            // If ignoreEmptyContainers is true, don't report the problem for
+            // empty containers (lists or dictionaries). We'll report the problem
+            // only if the assigned value is used later.
+            if (!ignoreEmptyContainers || !(0, types_1.isClassInstance)(type) || !type.priv.isEmptyContainer) {
+                const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                diagAddendum.addMessage(localize_1.LocAddendum.typeOfSymbol().format({
+                    name: nameValue,
+                    type: printType(simplifiedType, { expandTypeAlias: true }),
+                }));
+                addDiagnostic(rule, localize_1.LocMessage.typePartiallyUnknown().format({ name: nameValue }) + diagAddendum.getString(), errorNode);
+            }
+        }
+    }
+    function cloneBuiltinObjectWithLiteral(node, builtInName, value) {
+        const type = getBuiltInObject(node, builtInName);
+        if ((0, types_1.isClassInstance)(type)) {
+            return types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneRemoveTypePromotions(type), value);
+        }
+        return types_1.UnknownType.create();
+    }
+    function adjustParamAnnotatedType(param, type) {
+        // PEP 484 indicates that if a parameter has a default value of 'None'
+        // the type checker should assume that the type is optional (i.e. a union
+        // of the specified type and 'None'). Skip this step if the type is already
+        // optional to avoid losing alias names when combining the types.
+        if (param.d.defaultValue?.nodeType === 14 /* ParseNodeType.Constant */ &&
+            param.d.defaultValue.d.constType === 27 /* KeywordType.None */ &&
+            !(0, typeUtils_1.isOptionalType)(type) &&
+            !nodeInfo.getFileInfo(param).diagnosticRuleSet.strictParameterNoneValue) {
+            return (0, types_1.combineTypes)([type, getNoneType()]);
+        }
+        return type;
+    }
+    function inferParamTypeFromDefaultValue(paramValueExpr) {
+        const defaultValueType = getTypeOfExpression(paramValueExpr, 1 /* EvalFlags.ConvertEllipsisToAny */).type;
+        let inferredParamType;
+        // Is the default value a "None", a sentinel, or an instance of some private
+        // class (one whose name starts with an underscore)? If so, we will assume
+        // that the value is a singleton sentinel. The actual supported type is
+        // going to be a union of this type and Unknown.
+        if ((0, typeUtils_1.isNoneInstance)(defaultValueType) ||
+            (0, typeUtils_1.isSentinelLiteral)(defaultValueType) ||
+            ((0, types_1.isClassInstance)(defaultValueType) && (0, symbolNameUtils_1.isPrivateOrProtectedName)(defaultValueType.shared.name))) {
+            inferredParamType = (0, types_1.combineTypes)([defaultValueType, types_1.UnknownType.create()]);
+        }
+        else {
+            let skipInference = false;
+            if ((0, types_1.isFunctionOrOverloaded)(defaultValueType)) {
+                // Do not infer parameter types that use a lambda or another function as a
+                // default value. We're likely to generate false positives in this case.
+                // It's not clear whether parameters should be positional-only or not.
+                skipInference = true;
+            }
+            else if ((0, types_1.isClassInstance)(defaultValueType) &&
+                types_1.ClassType.isBuiltIn(defaultValueType, ['tuple', 'list', 'set', 'dict'])) {
+                // Do not infer certain types like tuple because it's likely to be
+                // more restrictive (narrower) than intended.
+                skipInference = true;
+            }
+            if (!skipInference) {
+                inferredParamType = convertSpecialFormToRuntimeValue(defaultValueType, 0 /* EvalFlags.None */, 
+                /* convertModule */ true);
+                inferredParamType = (0, typeUtils_1.stripTypeForm)(inferredParamType);
+                inferredParamType = stripLiteralValue(inferredParamType);
+            }
+        }
+        if (inferredParamType) {
+            const fileInfo = nodeInfo.getFileInfo(paramValueExpr);
+            if (fileInfo.isInPyTypedPackage && !fileInfo.isStubFile) {
+                inferredParamType = types_1.TypeBase.cloneForAmbiguousType(inferredParamType);
+            }
+        }
+        return inferredParamType;
+    }
+    function transformVariadicParamType(node, paramCategory, type) {
+        switch (paramCategory) {
+            case 0 /* ParamCategory.Simple */: {
+                return type;
+            }
+            case 1 /* ParamCategory.ArgsList */: {
+                if ((0, types_1.isParamSpec)(type) && type.priv.paramSpecAccess) {
+                    return type;
+                }
+                if ((0, types_1.isUnpackedClass)(type)) {
+                    return types_1.ClassType.cloneForPacked(type);
+                }
+                return (0, tuples_1.makeTupleObject)(evaluatorInterface, [{ type, isUnbounded: !(0, types_1.isTypeVarTuple)(type) }]);
+            }
+            case 2 /* ParamCategory.KwargsDict */: {
+                // Leave a ParamSpec alone.
+                if ((0, types_1.isParamSpec)(type) && type.priv.paramSpecAccess) {
+                    return type;
+                }
+                // Is this an unpacked TypedDict? If so, return its packed version.
+                if ((0, types_1.isClassInstance)(type) && types_1.ClassType.isTypedDictClass(type) && type.priv.isUnpacked) {
+                    return types_1.ClassType.cloneForPacked(type);
+                }
+                // Wrap the type in a dict with str keys.
+                const dictType = getBuiltInType(node, 'dict');
+                const strType = getBuiltInObject(node, 'str');
+                if ((0, types_1.isInstantiableClass)(dictType) && (0, types_1.isClassInstance)(strType)) {
+                    return types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(dictType, [strType, type]));
+                }
+                return types_1.UnknownType.create();
+            }
+        }
+    }
+    function methodAlwaysRaisesNotImplemented(functionDecl) {
+        if (!functionDecl ||
+            !functionDecl.isMethod ||
+            functionDecl.returnStatements ||
+            functionDecl.yieldStatements ||
+            !functionDecl.raiseStatements) {
+            return false;
+        }
+        const statements = functionDecl.node.d.suite.d.statements;
+        if (statements.some((statement) => statement.nodeType !== 47 /* ParseNodeType.StatementList */)) {
+            return false;
+        }
+        for (const raiseStatement of functionDecl.raiseStatements) {
+            if (!raiseStatement.d.expr || raiseStatement.d.fromExpr) {
+                return false;
+            }
+            const raiseType = getTypeOfExpression(raiseStatement.d.expr).type;
+            const classType = (0, types_1.isInstantiableClass)(raiseType)
+                ? raiseType
+                : (0, types_1.isClassInstance)(raiseType)
+                    ? raiseType
+                    : undefined;
+            if (!classType || !(0, typeUtils_1.derivesFromStdlibClass)(classType, 'NotImplementedError')) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function getTypeOfArgExpectingType(arg, options) {
+        if (arg.typeResult) {
+            return { type: arg.typeResult.type, isIncomplete: arg.typeResult.isIncomplete };
+        }
+        // If there was no defined type provided, there should always
+        // be a value expression from which we can retrieve the type.
+        (0, debug_1.assert)(arg.valueExpression !== undefined);
+        return getTypeOfExpressionExpectingType(arg.valueExpression, options);
+    }
+    function getBuiltInType(node, name) {
+        const scope = getScopeForNode(node);
+        if (scope) {
+            const builtInScope = ScopeUtils.getBuiltInScope(scope);
+            const nameType = builtInScope.lookUpSymbol(name);
+            if (nameType) {
+                return getEffectiveTypeOfSymbol(nameType);
+            }
+        }
+        return types_1.UnknownType.create();
+    }
+    function getBuiltInObject(node, name, typeArgs) {
+        const nameType = getBuiltInType(node, name);
+        if ((0, types_1.isInstantiableClass)(nameType)) {
+            let classType = nameType;
+            if (typeArgs) {
+                classType = types_1.ClassType.specialize(classType, typeArgs);
+            }
+            return types_1.ClassType.cloneAsInstance(classType);
+        }
+        return nameType;
+    }
+    function isUnambiguousInference(symbol, decl, inferredType) {
+        const nonSlotsDecls = symbol.getDeclarations().filter((decl) => {
+            return decl.type !== 1 /* DeclarationType.Variable */ || !decl.isInferenceAllowedInPyTyped;
+        });
+        // Any symbol with more than one assignment is considered ambiguous.
+        if (nonSlotsDecls.length > 1) {
+            return false;
+        }
+        if (decl.type !== 1 /* DeclarationType.Variable */) {
+            return false;
+        }
+        // If there are no non-slots declarations, don't mark the inferred type as ambiguous.
+        if (nonSlotsDecls.length === 0) {
+            return true;
+        }
+        // TypeVar definitions don't require a declaration.
+        if ((0, types_1.isTypeVar)(inferredType)) {
+            return true;
+        }
+        let assignmentNode;
+        const parentNode = decl.node.parent;
+        if (parentNode) {
+            // Is this a simple assignment (x = y) or an assignment of an instance variable (self.x = y)?
+            if (parentNode.nodeType === 3 /* ParseNodeType.Assignment */) {
+                assignmentNode = parentNode;
+            }
+            else if (parentNode.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
+                parentNode.parent?.nodeType === 3 /* ParseNodeType.Assignment */) {
+                assignmentNode = parentNode.parent;
+            }
+        }
+        if (!assignmentNode) {
+            return false;
+        }
+        const assignedType = getTypeOfExpression(assignmentNode.d.rightExpr).type;
+        // Assume that literal values will always result in the same inferred type.
+        if ((0, types_1.isClassInstance)(assignedType) && (0, typeUtils_1.isLiteralType)(assignedType)) {
+            return true;
+        }
+        // If the assignment is a simple name corresponding to an unambiguous
+        // type, we'll assume the resulting variable will receive the same
+        // unambiguous type.
+        if (assignmentNode.d.rightExpr.nodeType === 38 /* ParseNodeType.Name */ && !types_1.TypeBase.isAmbiguous(assignedType)) {
+            return true;
+        }
+        return false;
+    }
+    function isSpecialFormClass(classType, flags) {
+        if ((flags & 16384 /* AssignTypeFlags.AllowIsinstanceSpecialForms */) !== 0) {
+            return false;
+        }
+        return types_1.ClassType.isSpecialFormClass(classType);
+    }
+    function isTypeSubsumedByOtherType(type, otherType, allowAnyToSubsume, recursionCount = 0) {
+        const concreteType = makeTopLevelTypeVarsConcrete(type);
+        const otherSubtypes = (0, types_1.isUnion)(otherType) ? otherType.priv.subtypes : [otherType];
+        for (const otherSubtype of otherSubtypes) {
+            if ((0, types_1.isTypeSame)(otherSubtype, type)) {
+                continue;
+            }
+            if ((0, types_1.isAnyOrUnknown)(otherSubtype)) {
+                if (allowAnyToSubsume) {
+                    return true;
+                }
+            }
+            else if (isProperSubtype(otherSubtype, concreteType, recursionCount)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    function isProperSubtype(destType, srcType, recursionCount) {
+        // If the destType has a condition, don't consider the srcType a proper subtype.
+        if (destType.props?.condition) {
+            return false;
+        }
+        // Shortcut the check if either type is Any or Unknown.
+        if ((0, types_1.isAnyOrUnknown)(destType) || (0, types_1.isAnyOrUnknown)(srcType)) {
+            return true;
+        }
+        // Shortcut the check if either type is a class whose hierarchy contains an unknown type.
+        if ((0, types_1.isClass)(destType) && destType.shared.mro.some((mro) => (0, types_1.isAnyOrUnknown)(mro))) {
+            return true;
+        }
+        if ((0, types_1.isClass)(srcType) && srcType.shared.mro.some((mro) => (0, types_1.isAnyOrUnknown)(mro))) {
+            return true;
+        }
+        return (assignType(destType, srcType, 
+        /* diag */ undefined, 
+        /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount) &&
+            !assignType(srcType, destType, 
+            /* diag */ undefined, 
+            /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount));
+    }
+    function isTypeComparable(leftType, rightType, assumeIsOperator = false) {
+        if ((0, types_1.isAnyOrUnknown)(leftType) || (0, types_1.isAnyOrUnknown)(rightType)) {
+            return true;
+        }
+        if ((0, types_1.isNever)(leftType) || (0, types_1.isNever)(rightType)) {
+            return false;
+        }
+        if ((0, types_1.isModule)(leftType) || (0, types_1.isModule)(rightType)) {
+            return (0, types_1.isTypeSame)(leftType, rightType, { ignoreConditions: true });
+        }
+        const isLeftCallable = (0, types_1.isFunctionOrOverloaded)(leftType);
+        const isRightCallable = (0, types_1.isFunctionOrOverloaded)(rightType);
+        // If either type is a function, assume that it may be comparable. The other
+        // operand might be a callable object, an 'object' instance, etc. We could
+        // make this more precise for specific cases (e.g. if the other operand is
+        // None or a literal or an instance of a nominal class that doesn't override
+        // __call__ and is marked final, etc.), but coming up with a comprehensive
+        // list is probably not feasible.
+        if (isLeftCallable || isRightCallable) {
+            return true;
+        }
+        if ((0, types_1.isInstantiableClass)(leftType) || ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, 'type'))) {
+            if ((0, types_1.isInstantiableClass)(rightType) ||
+                ((0, types_1.isClassInstance)(rightType) && types_1.ClassType.isBuiltIn(rightType, 'type'))) {
+                const genericLeftType = types_1.ClassType.specialize(leftType, /* typeArgs */ undefined);
+                const genericRightType = types_1.ClassType.specialize(rightType, /* typeArgs */ undefined);
+                if (assignType(genericLeftType, genericRightType) || assignType(genericRightType, genericLeftType)) {
+                    return true;
+                }
+            }
+            // Does the class have an operator overload for eq?
+            const metaclass = leftType.shared.effectiveMetaclass;
+            if (metaclass && (0, types_1.isClass)(metaclass)) {
+                if ((0, typeUtils_1.lookUpClassMember)(metaclass, '__eq__', 4 /* MemberAccessFlags.SkipObjectBaseClass */)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        if ((0, types_1.isClassInstance)(leftType)) {
+            if ((0, types_1.isClass)(rightType)) {
+                const genericLeftType = types_1.ClassType.specialize(leftType, /* typeArgs */ undefined);
+                const genericRightType = types_1.ClassType.specialize(rightType, /* typeArgs */ undefined);
+                if (assignType(genericLeftType, genericRightType) || assignType(genericRightType, genericLeftType)) {
+                    return true;
+                }
+                // Check for the "is None" or "is not None" case.
+                if (assumeIsOperator && (0, typeUtils_1.isNoneInstance)(rightType)) {
+                    if ((0, typeUtils_1.isNoneInstance)(leftType)) {
+                        return true;
+                    }
+                    // The LHS could be a protocol or 'object', in which case None is
+                    // potentially comparable to it. In other cases, None is not comparable
+                    // because the types are disjoint.
+                    return assignType(leftType, rightType);
+                }
+                // Assume that if the types are disjoint and built-in classes that they
+                // will never be comparable.
+                if (types_1.ClassType.isBuiltIn(leftType) && types_1.ClassType.isBuiltIn(rightType) && types_1.TypeBase.isInstance(rightType)) {
+                    // We need to be careful with bool and int literals because
+                    // they are comparable under certain circumstances.
+                    let boolType;
+                    let intType;
+                    if (types_1.ClassType.isBuiltIn(leftType, 'bool') && types_1.ClassType.isBuiltIn(rightType, 'int')) {
+                        boolType = leftType;
+                        intType = rightType;
+                    }
+                    else if (types_1.ClassType.isBuiltIn(rightType, 'bool') && types_1.ClassType.isBuiltIn(leftType, 'int')) {
+                        boolType = rightType;
+                        intType = leftType;
+                    }
+                    if (boolType && intType) {
+                        const intVal = intType.priv?.literalValue;
+                        if (intVal === undefined) {
+                            return true;
+                        }
+                        if (intVal !== 0 && intVal !== 1) {
+                            return false;
+                        }
+                        const boolVal = boolType.priv?.literalValue;
+                        if (boolVal === undefined) {
+                            return true;
+                        }
+                        return boolVal === (intVal === 1);
+                    }
+                    // Distinct bytes-like classes support cross-type equality regardless
+                    // of disableBytesTypePromotions. Don't apply this to the same class:
+                    // different bytes literals must remain disjoint.
+                    if (!assumeIsOperator &&
+                        !types_1.ClassType.isSameGenericClass(leftType, rightType) &&
+                        isTypePromotionRelated(leftType, rightType)) {
+                        return true;
+                    }
+                    return false;
+                }
+            }
+            // Does the class have an operator overload for eq?
+            const eqMethod = (0, typeUtils_1.lookUpClassMember)(types_1.ClassType.cloneAsInstantiable(leftType), '__eq__', 4 /* MemberAccessFlags.SkipObjectBaseClass */);
+            if (eqMethod) {
+                // If this is a synthesized method for a dataclass, we can assume
+                // that other dataclass types will not be comparable.
+                if (types_1.ClassType.isDataClass(leftType) && eqMethod.symbol.getSynthesizedType()) {
+                    return false;
+                }
+                return true;
+            }
+            return false;
+        }
+        return true;
+    }
+    function isFinalVariable(symbol) {
+        return symbol.getDeclarations().some((decl) => isFinalVariableDeclaration(decl));
+    }
+    function isFinalVariableDeclaration(decl) {
+        return decl.type === 1 /* DeclarationType.Variable */ && !!decl.isFinal;
+    }
+    function isLegalTypeAliasExpressionForm(node, allowStrLiteral) {
+        switch (node.nodeType) {
+            case 0 /* ParseNodeType.Error */:
+            case 55 /* ParseNodeType.UnaryOperation */:
+            case 4 /* ParseNodeType.AssignmentExpression */:
+            case 54 /* ParseNodeType.TypeAnnotation */:
+            case 6 /* ParseNodeType.Await */:
+            case 51 /* ParseNodeType.Ternary */:
+            case 56 /* ParseNodeType.Unpack */:
+            case 52 /* ParseNodeType.Tuple */:
+            case 9 /* ParseNodeType.Call */:
+            case 11 /* ParseNodeType.Comprehension */:
+            case 46 /* ParseNodeType.Slice */:
+            case 60 /* ParseNodeType.Yield */:
+            case 61 /* ParseNodeType.YieldFrom */:
+            case 33 /* ParseNodeType.Lambda */:
+            case 40 /* ParseNodeType.Number */:
+            case 18 /* ParseNodeType.Dictionary */:
+            case 34 /* ParseNodeType.List */:
+            case 45 /* ParseNodeType.Set */:
+                return false;
+            case 48 /* ParseNodeType.StringList */:
+            case 49 /* ParseNodeType.String */:
+                return allowStrLiteral;
+            case 14 /* ParseNodeType.Constant */:
+                return node.d.constType === 27 /* KeywordType.None */;
+            case 7 /* ParseNodeType.BinaryOperation */:
+                return (node.d.operator === 6 /* OperatorType.BitwiseOr */ &&
+                    isLegalTypeAliasExpressionForm(node.d.leftExpr, /* allowStrLiteral */ true) &&
+                    isLegalTypeAliasExpressionForm(node.d.rightExpr, /* allowStrLiteral */ true));
+            case 27 /* ParseNodeType.Index */:
+                return isLegalTypeAliasExpressionForm(node.d.leftExpr, allowStrLiteral);
+            case 35 /* ParseNodeType.MemberAccess */:
+                return isLegalTypeAliasExpressionForm(node.d.leftExpr, allowStrLiteral);
+        }
+        return true;
+    }
+    function isPossibleTypeDictFactoryCall(decl) {
+        if (decl.type !== 1 /* DeclarationType.Variable */ ||
+            !decl.node.parent ||
+            decl.node.parent.nodeType !== 3 /* ParseNodeType.Assignment */ ||
+            decl.node.parent.d.rightExpr?.nodeType !== 9 /* ParseNodeType.Call */) {
+            return false;
+        }
+        const callLeftNode = decl.node.parent.d.rightExpr.d.leftExpr;
+        // Use a simple heuristic to determine whether this is potentially
+        // a call to the TypedDict call. This avoids the expensive (and potentially
+        // recursive) call to getTypeOfExpression in cases where it's not needed.
+        if ((callLeftNode.nodeType === 38 /* ParseNodeType.Name */ && callLeftNode.d.value) === 'TypedDict' ||
+            (callLeftNode.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
+                callLeftNode.d.member.d.value === 'TypedDict' &&
+                callLeftNode.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */)) {
+            // See if this is a call to TypedDict. We want to support
+            // recursive type references in a TypedDict call.
+            const callType = getTypeOfExpression(callLeftNode, 2 /* EvalFlags.CallBaseDefaults */).type;
+            if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'TypedDict')) {
+                return true;
+            }
+        }
+        return false;
+    }
+    return {
+        validateTypeIsInstantiable,
+        solveAndApplyConstraints,
+        getBoundMagicMethod,
+        getTypeOfAwaitable,
+        isTypeHashable,
+        getTypedDictClassType,
+        getTupleClassType,
+        getDictClassType,
+        getStrClassType,
+        getObjectType,
+        getNoneType,
+        getUnionClassType,
+        getTypeClassType,
+        verifyRaiseExceptionType,
+        isSymbolValidTypeExpression,
+        convertSpecialFormToRuntimeValue,
+        reportMissingTypeArgs,
+        specializeTypeAliasWithDefaults,
+        buildTupleTypesList,
+        convertNodeToArg,
+        getSpeculativeNodeForCall,
+        getAbstractSymbolInfo,
+        validateCallForClassInstance,
+        adjustCallableReturnType,
+        getFunctionFullName,
+        reportPossibleUnknownAssignment,
+        cloneBuiltinObjectWithLiteral,
+        adjustParamAnnotatedType,
+        inferParamTypeFromDefaultValue,
+        transformVariadicParamType,
+        methodAlwaysRaisesNotImplemented,
+        getTypeOfArgExpectingType,
+        getBuiltInType,
+        getBuiltInObject,
+        isUnambiguousInference,
+        isSpecialFormClass,
+        isTypeSubsumedByOtherType,
+        isTypeComparable,
+        isFinalVariable,
+        isFinalVariableDeclaration,
+        isLegalTypeAliasExpressionForm,
+        isPossibleTypeDictFactoryCall,
+    };
+}
+//# sourceMappingURL=evaluatorCore.js.map