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

package/dist/analyzer/typeEvaluator/expressionEvaluation.js

@@ -0,0 +1,1802 @@
+"use strict";
+/*
+ * expressionEvaluation.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * expressionEvaluation 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.getIndexAccessMagicMethodName = getIndexAccessMagicMethodName;
+exports.createExpressionEvaluation = createExpressionEvaluation;
+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 parser_1 = require("../../parser/parser");
+const analyzerFileInfo_1 = require("../analyzerFileInfo");
+const decorators_1 = require("../decorators");
+const ParseTreeUtils = __importStar(require("../parseTreeUtils"));
+const tuples_1 = require("../tuples");
+const typedDicts_1 = require("../typedDicts");
+const typeGuards_1 = require("../typeGuards");
+const types_1 = require("../types");
+const typeUtils_1 = require("../typeUtils");
+function getIndexAccessMagicMethodName(usage) {
+    if (usage.method === 'get') {
+        return '__getitem__';
+    }
+    else if (usage.method === 'set') {
+        return '__setitem__';
+    }
+    else {
+        (0, debug_1.assert)(usage.method === 'del');
+        return '__delitem__';
+    }
+}
+// Evaluates expression forms and expands call arguments using evaluator-owned caches and callbacks.
+function createExpressionEvaluation(context) {
+    const { addDiagnostic, addInformation, cloneBuiltinObjectWithLiteral, collectLiteralEnumClasses, convertNodeToArg, evaluatorInterface, expectedTypeWantsTypeForm, getBoundMagicMethod, getBuiltInObject, getBuiltInType, getDeclaredTypeOfSymbol, getEffectiveTypeOfSymbol, getNoneType, getObjectType, getScopeForNode, getTypeOfArgExpectingType, getTypeOfAwaitable, getTypeOfClass, getTypeOfExpression, getTypeOfFunction, getTypeVarScopesForNode, getTypingType, isSpeculativeModeInUse, lookUpSymbolRecursive, makeTopLevelTypeVarsConcrete, mapSubtypesExpandTypeVars, nodeInfo, normalizeEnumTypes, printSrcDestTypes, printType, resolveDeclaredMemberType, setTypeResultForNode, stripTypeGuard, useSpeculativeMode, validateCallArgs, maxSingleOverloadArgTypeExpansionCount, } = context;
+    function getTypeOfEllipsis(flags, typeResult, node) {
+        if ((flags & 1 /* EvalFlags.ConvertEllipsisToAny */) !== 0) {
+            typeResult = { type: types_1.AnyType.create(/* isEllipsis */ true) };
+        }
+        else {
+            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0 && (flags & 65536 /* EvalFlags.AllowEllipsis */) === 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.ellipsisContext(), node);
+                typeResult = { type: types_1.UnknownType.create() };
+            }
+            else {
+                const ellipsisType = getBuiltInObject(node, 'EllipsisType') ?? getBuiltInObject(node, 'ellipsis') ?? types_1.AnyType.create();
+                typeResult = { type: ellipsisType };
+            }
+        }
+        return typeResult;
+    }
+    function getTypeOfUnpackOperator(node, flags, inferenceContext) {
+        let typeResult;
+        let iterExpectedType;
+        if (inferenceContext) {
+            const iterableType = getBuiltInType(node, 'Iterable');
+            if (iterableType && (0, types_1.isInstantiableClass)(iterableType)) {
+                iterExpectedType = types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(iterableType, [inferenceContext.expectedType]));
+            }
+        }
+        const iterTypeResult = getTypeOfExpression(node.d.expr, flags, (0, typeUtils_1.makeInferenceContext)(iterExpectedType));
+        const iterType = iterTypeResult.type;
+        if ((flags & 64 /* EvalFlags.NoTypeVarTuple */) === 0 && (0, types_1.isTypeVarTuple)(iterType) && !iterType.priv.isUnpacked) {
+            typeResult = { type: types_1.TypeVarType.cloneForUnpacked(iterType) };
+        }
+        else if ((flags & 4194304 /* EvalFlags.AllowUnpackedTuple */) !== 0 &&
+            (0, types_1.isInstantiableClass)(iterType) &&
+            types_1.ClassType.isBuiltIn(iterType, 'tuple')) {
+            typeResult = { type: types_1.ClassType.cloneForUnpacked(iterType) };
+        }
+        else if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackInAnnotation(), node, node.d.starToken);
+            typeResult = { type: types_1.UnknownType.create() };
+        }
+        else {
+            const iteratorTypeResult = getTypeOfIterator(iterTypeResult, /* isAsync */ false, node) ?? {
+                type: types_1.UnknownType.create(!!iterTypeResult.isIncomplete),
+                isIncomplete: iterTypeResult.isIncomplete,
+            };
+            typeResult = {
+                type: iteratorTypeResult.type,
+                typeErrors: iterTypeResult.typeErrors,
+                unpackedType: iterType,
+                isIncomplete: iteratorTypeResult.isIncomplete,
+            };
+        }
+        return typeResult;
+    }
+    // Calls back into the parser to parse the contents of a string literal.
+    // This is unfortunately needed in some cases — specifically where the
+    // parser couldn't determine that the string literal would be used in
+    // a context where it should be treated as a forward-declared type. This
+    // call produces an expression tree that is not attached to the main parse
+    // expression tree because we don't want to mutate the latter; the
+    // expression tree created by this function is therefore used only temporarily.
+    function parseStringAsTypeAnnotation(node, reportErrors) {
+        const fileInfo = nodeInfo.getFileInfo(node);
+        const parser = new parser_1.Parser();
+        const textValue = node.d.strings[0].d.value;
+        // Determine the offset within the file where the string
+        // literal's contents begin.
+        let valueOffset = node.d.strings[0].start;
+        if (node.d.strings[0].nodeType === 49 /* ParseNodeType.String */) {
+            valueOffset += node.d.strings[0].d.token.prefixLength + node.d.strings[0].d.token.quoteMarkLength;
+        }
+        // Construct a temporary dummy string with the text value at the appropriate
+        // offset so as to mimic the original file. This will keep all of the token
+        // and diagnostic offsets correct.
+        const dummyFileContents = ' '.repeat(valueOffset) + textValue;
+        const parseOptions = new parser_1.ParseOptions();
+        parseOptions.isStubFile = fileInfo.isStubFile;
+        parseOptions.pythonVersion = fileInfo.executionEnvironment.pythonVersion;
+        parseOptions.reportErrorsForParsedStringContents = true;
+        const parseResults = parser.parseTextExpression(dummyFileContents, valueOffset, textValue.length, parseOptions, 0 /* ParseTextMode.Expression */, 
+        /* initialParenDepth */ undefined, fileInfo.typingSymbolAliases, node.a);
+        if (parseResults.parseTree) {
+            // If there are errors but we are not reporting them, return
+            // undefined to indicate that the parse failed.
+            if (!reportErrors && parseResults.diagnostics.length > 0) {
+                return undefined;
+            }
+            const fileInfo = nodeInfo.getFileInfo(node);
+            parseResults.diagnostics.forEach((diag) => {
+                fileInfo.diagnosticSink.addDiagnosticWithTextRange('error', diag.message, node);
+            });
+            parseResults.parseTree.parent = node;
+            // Optionally add the new subtree to the parse tree so it can
+            // participate in language server operations like find and replace.
+            if (reportErrors) {
+                nodeInfo.setStringAnnotation(node, parseResults.parseTree, parseResults.stringAnnotations);
+            }
+            return parseResults.parseTree;
+        }
+        return undefined;
+    }
+    function getTypeOfStringList(node, flags, inferenceContext) {
+        let typeResult;
+        if ((flags & 8 /* EvalFlags.StrLiteralAsType */) !== 0 &&
+            ((flags & 1073741824 /* EvalFlags.TypeFormArg */) === 0 || (flags & 33554432 /* EvalFlags.NoConvertSpecialForm */) !== 0)) {
+            return getTypeOfStringListAsType(node, flags);
+        }
+        const isBytesNode = (node) => (node.d.token.flags & 32 /* StringTokenFlags.Bytes */) !== 0;
+        const isTemplateNode = (node) => (node.d.token.flags & 128 /* StringTokenFlags.Template */) !== 0;
+        // Check for mixing of t-string literals with str, bytes, or f-string
+        // literals. CPython reports this as a SyntaxError (PEP 750).
+        const firstTemplateIndex = node.d.strings.findIndex(isTemplateNode);
+        const firstNonTemplateIndex = node.d.strings.findIndex((str) => !isTemplateNode(str));
+        if (firstTemplateIndex >= 0 && firstNonTemplateIndex >= 0) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.mixingTemplateAndStr(), node.d.strings[Math.max(firstTemplateIndex, firstNonTemplateIndex)]);
+            return { type: types_1.UnknownType.create() };
+        }
+        // Check for mixing of bytes and str, which is not allowed.
+        const firstStrIndex = node.d.strings.findIndex((str) => !isBytesNode(str));
+        const firstBytesIndex = node.d.strings.findIndex((str) => isBytesNode(str));
+        if (firstStrIndex >= 0 && firstBytesIndex >= 0) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.mixingBytesAndStr(), node.d.strings[Math.max(firstBytesIndex, firstStrIndex)]);
+            return { type: types_1.UnknownType.create() };
+        }
+        const isBytes = firstBytesIndex >= 0;
+        let isLiteralString = true;
+        let isIncomplete = false;
+        let isTemplate = false;
+        node.d.strings.forEach((expr) => {
+            // Handle implicit concatenation.
+            const typeResult = getTypeOfString(expr);
+            if (typeResult.isIncomplete) {
+                isIncomplete = true;
+            }
+            let isExprLiteralString = false;
+            if ((0, types_1.isClassInstance)(typeResult.type)) {
+                if (types_1.ClassType.isBuiltIn(typeResult.type, 'str') && typeResult.type.priv.literalValue !== undefined) {
+                    isExprLiteralString = true;
+                }
+                else if (types_1.ClassType.isBuiltIn(typeResult?.type, 'LiteralString')) {
+                    isExprLiteralString = true;
+                }
+                if (typeResult.type.shared.name === 'Template') {
+                    isTemplate = true;
+                }
+            }
+            if (!isExprLiteralString) {
+                isLiteralString = false;
+            }
+        });
+        if (isTemplate) {
+            const templateType = context.prefetched?.templateClass && (0, types_1.isInstantiableClass)(context.prefetched?.templateClass)
+                ? types_1.ClassType.cloneAsInstance(context.prefetched.templateClass)
+                : types_1.UnknownType.create();
+            typeResult = { type: templateType, isIncomplete };
+        }
+        else if (node.d.strings.some((str) => str.nodeType === 30 /* ParseNodeType.FormatString */)) {
+            if (isLiteralString) {
+                const literalStringType = getTypingType(node, 'LiteralString');
+                if (literalStringType && (0, types_1.isInstantiableClass)(literalStringType)) {
+                    typeResult = { type: types_1.ClassType.cloneAsInstance(literalStringType) };
+                }
+            }
+            if (!typeResult) {
+                typeResult = {
+                    type: getBuiltInObject(node, isBytes ? 'bytes' : 'str'),
+                    isIncomplete,
+                };
+            }
+        }
+        else {
+            typeResult = {
+                type: cloneBuiltinObjectWithLiteral(node, isBytes ? 'bytes' : 'str', node.d.strings.map((s) => s.d.value).join('')),
+                isIncomplete,
+            };
+        }
+        if (node.d.strings.length !== 1 || node.d.strings[0].nodeType !== 49 /* ParseNodeType.String */) {
+            return typeResult;
+        }
+        // Only attempt to interpret the string as a TypeForm forward reference when
+        // there's a signal that a TypeForm value is wanted in this context. Doing it
+        // unconditionally can trigger expensive (and recursion-prone) type lookups
+        // for plain string literals in non-type contexts.
+        const wantsTypeForm = (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 ||
+            (inferenceContext !== undefined && expectedTypeWantsTypeForm(inferenceContext.expectedType));
+        if (!wantsTypeForm) {
+            return typeResult;
+        }
+        // For performance reasons, do not attempt to treat the string literal
+        // as a TypeForm if it's going to fail anyway or is unlikely to be a
+        // TypeForm (really long, triple-quoted, etc.).
+        const stringNode = node.d.strings[0];
+        const tokenFlags = stringNode.d.token.flags;
+        const disallowedTokenFlags = 32 /* StringTokenFlags.Bytes */ |
+            8 /* StringTokenFlags.Raw */ |
+            64 /* StringTokenFlags.Format */ |
+            128 /* StringTokenFlags.Template */ |
+            4 /* StringTokenFlags.Triplicate */;
+        const maxTypeFormStringLength = 256;
+        if ((tokenFlags & disallowedTokenFlags) !== 0 ||
+            stringNode.d.token.escapedValue.length >= maxTypeFormStringLength) {
+            return typeResult;
+        }
+        const typeFormResult = getTypeOfStringListAsType(node, flags);
+        if (typeFormResult.type.props?.typeForm) {
+            typeResult.type = types_1.TypeBase.cloneWithTypeForm(typeResult.type, typeFormResult.type.props.typeForm);
+        }
+        return typeResult;
+    }
+    function getTypeOfStringListAsType(node, flags) {
+        const reportTypeErrors = (flags & 8 /* EvalFlags.StrLiteralAsType */) !== 0;
+        let updatedFlags = flags | 4 /* EvalFlags.ForwardRefs */ | 128 /* EvalFlags.InstantiableType */;
+        let typeResult;
+        // In most cases, annotations within a string are not parsed by the interpreter.
+        // There are a few exceptions (e.g. the "bound" value for a TypeVar constructor).
+        if ((flags & 16777216 /* EvalFlags.ParsesStringLiteral */) === 0) {
+            updatedFlags |= 524288 /* EvalFlags.NotParsed */;
+        }
+        const annotation = nodeInfo.getStringAnnotation(node);
+        if (annotation && (flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+            return getTypeOfExpression(annotation, updatedFlags);
+        }
+        if (node.d.strings.length === 1) {
+            const tokenFlags = node.d.strings[0].d.token.flags;
+            if (tokenFlags & 32 /* StringTokenFlags.Bytes */) {
+                if (reportTypeErrors) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationBytesString(), node);
+                }
+                return { type: types_1.UnknownType.create() };
+            }
+            if (tokenFlags & 8 /* StringTokenFlags.Raw */) {
+                if (reportTypeErrors) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationRawString(), node);
+                }
+                return { type: types_1.UnknownType.create() };
+            }
+            if (tokenFlags & 64 /* StringTokenFlags.Format */) {
+                if (reportTypeErrors) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationFormatString(), node);
+                }
+                return { type: types_1.UnknownType.create() };
+            }
+            if (tokenFlags & 128 /* StringTokenFlags.Template */) {
+                if (reportTypeErrors) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.annotationTemplateString(), node);
+                }
+                return { type: types_1.UnknownType.create() };
+            }
+            // We didn't know at parse time that this string node was going
+            // to be evaluated as a forward-referenced type. We need
+            // to re-invoke the parser at this stage.
+            const expr = parseStringAsTypeAnnotation(node, reportTypeErrors);
+            if (expr) {
+                typeResult = useSpeculativeMode(reportTypeErrors ? undefined : node, () => {
+                    return getTypeOfExpression(expr, updatedFlags);
+                });
+            }
+        }
+        if (!typeResult) {
+            if (reportTypeErrors) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.expectedTypeNotString(), node);
+            }
+            typeResult = { type: types_1.UnknownType.create() };
+        }
+        return typeResult;
+    }
+    function getTypeOfString(node) {
+        const isBytes = (node.d.token.flags & 32 /* StringTokenFlags.Bytes */) !== 0;
+        let typeResult;
+        let isIncomplete = false;
+        if (node.nodeType === 49 /* ParseNodeType.String */) {
+            typeResult = {
+                type: cloneBuiltinObjectWithLiteral(node, isBytes ? 'bytes' : 'str', node.d.value),
+                isIncomplete,
+            };
+        }
+        else {
+            const isTemplateString = (node.d.token.flags & 128 /* StringTokenFlags.Template */) !== 0;
+            let isLiteralString = true;
+            // If all of the format expressions are of type LiteralString, then
+            // the resulting formatted string is also LiteralString.
+            node.d.fieldExprs.forEach((expr) => {
+                const exprTypeResult = getTypeOfExpression(expr);
+                const exprType = exprTypeResult.type;
+                if (exprTypeResult.isIncomplete) {
+                    isIncomplete = true;
+                }
+                (0, typeUtils_1.doForEachSubtype)(exprType, (exprSubtype) => {
+                    if (!(0, types_1.isClassInstance)(exprSubtype)) {
+                        isLiteralString = false;
+                        return;
+                    }
+                    if (types_1.ClassType.isBuiltIn(exprSubtype, 'LiteralString')) {
+                        return;
+                    }
+                    if (types_1.ClassType.isBuiltIn(exprSubtype, 'str') && exprSubtype.priv.literalValue !== undefined) {
+                        return;
+                    }
+                    isLiteralString = false;
+                });
+            });
+            if (isTemplateString) {
+                const templateType = context.prefetched?.templateClass && (0, types_1.isInstantiableClass)(context.prefetched?.templateClass)
+                    ? types_1.ClassType.cloneAsInstance(context.prefetched.templateClass)
+                    : types_1.UnknownType.create();
+                typeResult = { type: templateType, isIncomplete };
+            }
+            else if (!isBytes && isLiteralString) {
+                const literalStringType = getTypingType(node, 'LiteralString');
+                if (literalStringType && (0, types_1.isInstantiableClass)(literalStringType)) {
+                    typeResult = { type: types_1.ClassType.cloneAsInstance(literalStringType), isIncomplete };
+                }
+            }
+            if (!typeResult) {
+                typeResult = {
+                    type: getBuiltInObject(node, isBytes ? 'bytes' : 'str'),
+                    isIncomplete,
+                };
+                if ((0, types_1.isClass)(typeResult.type) && typeResult.type.priv.includePromotions) {
+                    typeResult.type = types_1.ClassType.cloneRemoveTypePromotions(typeResult.type);
+                }
+            }
+        }
+        return typeResult;
+    }
+    function getDeclaredTypeForExpression(expression, usage) {
+        let symbol;
+        let selfType;
+        let classOrObjectBase;
+        let memberAccessClass;
+        let bindFunction = true;
+        let useDescriptorSetterType = false;
+        switch (expression.nodeType) {
+            case 38 /* ParseNodeType.Name */: {
+                const symbolWithScope = lookUpSymbolRecursive(expression, expression.d.value, /* honorCodeFlow */ true);
+                if (symbolWithScope) {
+                    symbol = symbolWithScope.symbol;
+                    // Handle the case where the symbol is a class-level variable
+                    // where the type isn't declared in this class but is in
+                    // a parent class.
+                    if (!getDeclaredTypeOfSymbol(symbol, expression)?.type &&
+                        symbolWithScope.scope.type === 3 /* ScopeType.Class */) {
+                        const enclosingClass = ParseTreeUtils.getEnclosingClassOrFunction(expression);
+                        if (enclosingClass && enclosingClass.nodeType === 10 /* ParseNodeType.Class */) {
+                            const classTypeInfo = getTypeOfClass(enclosingClass);
+                            if (classTypeInfo) {
+                                const classMemberInfo = (0, typeUtils_1.lookUpClassMember)(classTypeInfo.classType, expression.d.value, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 64 /* MemberAccessFlags.DeclaredTypesOnly */);
+                                if (classMemberInfo) {
+                                    symbol = classMemberInfo.symbol;
+                                }
+                            }
+                        }
+                    }
+                }
+                break;
+            }
+            case 54 /* ParseNodeType.TypeAnnotation */: {
+                return getDeclaredTypeForExpression(expression.d.valueExpr, usage);
+            }
+            case 35 /* ParseNodeType.MemberAccess */: {
+                const baseType = getTypeOfExpression(expression.d.leftExpr, 2 /* EvalFlags.MemberAccessBaseDefaults */).type;
+                const baseTypeConcrete = makeTopLevelTypeVarsConcrete(baseType);
+                const memberName = expression.d.member.d.value;
+                if ((0, types_1.isTypeVar)(baseType)) {
+                    selfType = baseType;
+                }
+                // Normally, baseType will not be a composite type (a union), but
+                // this can occur. In this case, we compute the declared type of the
+                // member for each subtype. If the subtypes declare the member with
+                // the same generic class but different (invariant) type arguments
+                // (e.g. "list[int]" vs. "list[str]"), there is no single declared
+                // type that can serve as the expected type for bidirectional
+                // inference of an assigned value. Committing to one subtype's
+                // declared type produces a false positive when assigning a value
+                // (such as an empty container) that is compatible with every
+                // subtype, so in that case we return undefined and let the value be
+                // evaluated without an expected type. We sort the subtypes for
+                // determinism.
+                //
+                // This is deliberately limited to the "same class, differing type
+                // arguments" case. When the subtypes declare the member with
+                // unrelated types, we retain the previous behavior (use one
+                // subtype's declared type) so that genuine assignment errors are
+                // still reported at the same location and downstream inference is
+                // unchanged.
+                //
+                // This handling is further limited to cases where the declared base
+                // type is itself a union. We intentionally don't apply it when the
+                // base is a type variable that merely concretizes to a union.
+                const isUnionBase = (0, types_1.isUnion)(baseType);
+                let firstMemberDeclaredType;
+                let sawMemberDeclaredType = false;
+                let hasDivergentMemberDeclaredTypes = false;
+                let divergesOnlyByTypeArgs = true;
+                (0, typeUtils_1.doForEachSubtype)(baseTypeConcrete, (baseSubtype) => {
+                    if ((0, types_1.isClassInstance)(baseSubtype)) {
+                        const classMemberInfo = (0, typeUtils_1.lookUpObjectMember)(baseSubtype, memberName, 64 /* MemberAccessFlags.DeclaredTypesOnly */);
+                        classOrObjectBase = baseSubtype;
+                        memberAccessClass = classMemberInfo?.classType;
+                        symbol = classMemberInfo?.symbol;
+                        useDescriptorSetterType = true;
+                        // If this is an instance member (e.g. a dataclass field), don't
+                        // bind it to the object if it's a function.
+                        bindFunction = !classMemberInfo?.isInstanceMember;
+                    }
+                    else if ((0, types_1.isInstantiableClass)(baseSubtype)) {
+                        const classMemberInfo = (0, typeUtils_1.lookUpClassMember)(baseSubtype, memberName, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 64 /* MemberAccessFlags.DeclaredTypesOnly */);
+                        classOrObjectBase = baseSubtype;
+                        memberAccessClass = classMemberInfo?.classType;
+                        symbol = classMemberInfo?.symbol;
+                        useDescriptorSetterType = false;
+                        bindFunction = true;
+                    }
+                    else if ((0, types_1.isModule)(baseSubtype)) {
+                        classOrObjectBase = undefined;
+                        memberAccessClass = undefined;
+                        symbol = types_1.ModuleType.getField(baseSubtype, memberName);
+                        if (symbol && !symbol.hasTypedDeclarations()) {
+                            // Do not use inferred types for the declared type.
+                            symbol = undefined;
+                        }
+                        useDescriptorSetterType = false;
+                        bindFunction = false;
+                    }
+                    // If the base is a union, verify that the subtypes agree on a
+                    // single declared type for the member.
+                    if (isUnionBase) {
+                        const subtypeDeclaredType = symbol
+                            ? resolveDeclaredMemberType(symbol, classOrObjectBase, memberAccessClass, useDescriptorSetterType, bindFunction, selfType)
+                            : undefined;
+                        if (subtypeDeclaredType) {
+                            if (!sawMemberDeclaredType) {
+                                firstMemberDeclaredType = subtypeDeclaredType;
+                                sawMemberDeclaredType = true;
+                            }
+                            else if (!firstMemberDeclaredType ||
+                                !(0, types_1.isTypeSame)(firstMemberDeclaredType, subtypeDeclaredType)) {
+                                hasDivergentMemberDeclaredTypes = true;
+                                // The false positive we're addressing is specific
+                                // to invariant type arguments of the same generic
+                                // class. If the divergent types aren't instances of
+                                // the same generic class, don't treat this as an
+                                // ambiguous declared type.
+                                if (!firstMemberDeclaredType ||
+                                    !(0, types_1.isClassInstance)(firstMemberDeclaredType) ||
+                                    !(0, types_1.isClassInstance)(subtypeDeclaredType) ||
+                                    !types_1.ClassType.isSameGenericClass(types_1.ClassType.cloneAsInstantiable(firstMemberDeclaredType), types_1.ClassType.cloneAsInstantiable(subtypeDeclaredType))) {
+                                    divergesOnlyByTypeArgs = false;
+                                }
+                            }
+                        }
+                    }
+                }, 
+                /* sortSubtypes */ true);
+                if (hasDivergentMemberDeclaredTypes && divergesOnlyByTypeArgs) {
+                    return undefined;
+                }
+                break;
+            }
+            case 27 /* ParseNodeType.Index */: {
+                const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.d.leftExpr, 2 /* EvalFlags.IndexBaseDefaults */).type);
+                if (baseType && (0, types_1.isClassInstance)(baseType)) {
+                    if (types_1.ClassType.isTypedDictClass(baseType)) {
+                        const typeFromTypedDict = (0, typedDicts_1.getTypeOfIndexedTypedDict)(evaluatorInterface, expression, baseType, usage || { method: 'get' });
+                        if (typeFromTypedDict) {
+                            return typeFromTypedDict.type;
+                        }
+                    }
+                    let setItemType = getBoundMagicMethod(baseType, '__setitem__');
+                    if (!setItemType) {
+                        break;
+                    }
+                    if ((0, types_1.isOverloaded)(setItemType)) {
+                        // Determine whether we need to use the slice overload.
+                        const expectsSlice = expression.d.items.length === 1 &&
+                            expression.d.items[0].d.valueExpr.nodeType === 46 /* ParseNodeType.Slice */;
+                        const overloads = types_1.OverloadedType.getOverloads(setItemType);
+                        setItemType = overloads.find((overload) => {
+                            if (overload.shared.parameters.length < 2) {
+                                return false;
+                            }
+                            const keyType = types_1.FunctionType.getParamType(overload, 0);
+                            const isSlice = (0, types_1.isClassInstance)(keyType) && types_1.ClassType.isBuiltIn(keyType, 'slice');
+                            return expectsSlice === isSlice;
+                        });
+                        if (!setItemType) {
+                            break;
+                        }
+                    }
+                    if ((0, types_1.isFunction)(setItemType) && setItemType.shared.parameters.length >= 2) {
+                        const paramType = types_1.FunctionType.getParamType(setItemType, 1);
+                        if (!(0, types_1.isAnyOrUnknown)(paramType)) {
+                            return paramType;
+                        }
+                    }
+                }
+                break;
+            }
+            case 52 /* ParseNodeType.Tuple */: {
+                // If this is a tuple expression with at least one item and no
+                // unpacked items, and all of the items have declared types,
+                // we can assume a declared type for the resulting tuple. This
+                // is needed to enable bidirectional type inference when assigning
+                // to an unpacked tuple.
+                if (expression.d.items.length > 0 &&
+                    !expression.d.items.some((item) => item.nodeType === 56 /* ParseNodeType.Unpack */)) {
+                    const itemTypes = [];
+                    expression.d.items.forEach((expr) => {
+                        const itemType = getDeclaredTypeForExpression(expr, usage);
+                        if (itemType) {
+                            itemTypes.push(itemType);
+                        }
+                    });
+                    if (itemTypes.length === expression.d.items.length) {
+                        // If all items have a declared type, return a tuple of those types.
+                        return (0, tuples_1.makeTupleObject)(evaluatorInterface, itemTypes.map((t) => {
+                            return { type: t, isUnbounded: false };
+                        }));
+                    }
+                }
+                break;
+            }
+        }
+        if (symbol) {
+            return resolveDeclaredMemberType(symbol, classOrObjectBase, memberAccessClass, useDescriptorSetterType, bindFunction, selfType);
+        }
+        return undefined;
+    }
+    function getTypeOfIterator(typeResult, isAsync, errorNode, emitNotIterableError = true) {
+        const iterMethodName = isAsync ? '__aiter__' : '__iter__';
+        const nextMethodName = isAsync ? '__anext__' : '__next__';
+        let isValidIterator = true;
+        let isIncomplete = typeResult.isIncomplete;
+        let type = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(typeResult.type);
+        type = makeTopLevelTypeVarsConcrete(type);
+        type = (0, types_1.removeUnbound)(type);
+        if ((0, typeUtils_1.isOptionalType)(type) && emitNotIterableError) {
+            if (!typeResult.isIncomplete) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOptionalIterable, localize_1.LocMessage.noneNotIterable(), errorNode);
+            }
+            type = (0, typeUtils_1.removeNoneFromUnion)(type);
+        }
+        const iterableType = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+            subtype = makeTopLevelTypeVarsConcrete(subtype);
+            if ((0, types_1.isAnyOrUnknown)(subtype)) {
+                return subtype;
+            }
+            const diag = new diagnostic_1.DiagnosticAddendum();
+            if ((0, types_1.isClass)(subtype)) {
+                // Handle an empty tuple specially.
+                if (types_1.TypeBase.isInstance(subtype) &&
+                    (0, typeUtils_1.isTupleClass)(subtype) &&
+                    subtype.priv.tupleTypeArgs &&
+                    subtype.priv.tupleTypeArgs.length === 0) {
+                    return types_1.NeverType.createNever();
+                }
+                const iterReturnType = getTypeOfMagicMethodCall(subtype, iterMethodName, [], errorNode)?.type;
+                if (!iterReturnType) {
+                    // There was no callable __iter__. The legacy sequence protocol
+                    // falls back to __getitem__, but CPython does that only when
+                    // __iter__ is missing. An explicit `__iter__ = None` (or any
+                    // non-callable __iter__) makes the object not iterable.
+                    let hasExplicitIterMember = false;
+                    if (!isAsync && (0, types_1.isClassInstance)(subtype)) {
+                        hasExplicitIterMember = !!(0, typeUtils_1.lookUpObjectMember)(subtype, iterMethodName, 16 /* MemberAccessFlags.SkipInstanceMembers */ |
+                            512 /* MemberAccessFlags.SkipAttributeAccessOverride */ |
+                            4 /* MemberAccessFlags.SkipObjectBaseClass */);
+                    }
+                    if (!isAsync && (0, types_1.isClassInstance)(subtype) && !hasExplicitIterMember) {
+                        const getItemReturnType = getTypeOfMagicMethodCall(subtype, '__getitem__', [
+                            {
+                                type: context.prefetched?.intClass && (0, types_1.isInstantiableClass)(context.prefetched.intClass)
+                                    ? types_1.ClassType.cloneAsInstance(context.prefetched.intClass)
+                                    : types_1.UnknownType.create(),
+                            },
+                        ], errorNode)?.type;
+                        if (getItemReturnType) {
+                            return getItemReturnType;
+                        }
+                    }
+                    diag.addMessage(localize_1.LocMessage.methodNotDefined().format({ name: iterMethodName }));
+                }
+                else {
+                    const iterReturnTypeDiag = new diagnostic_1.DiagnosticAddendum();
+                    const returnType = mapSubtypesExpandTypeVars(iterReturnType, /* options */ undefined, (subtype) => {
+                        if ((0, types_1.isAnyOrUnknown)(subtype)) {
+                            return subtype;
+                        }
+                        let nextReturnType = getTypeOfMagicMethodCall(subtype, nextMethodName, [], errorNode)?.type;
+                        if (!nextReturnType) {
+                            iterReturnTypeDiag.addMessage(localize_1.LocMessage.methodNotDefinedOnType().format({
+                                name: nextMethodName,
+                                type: printType(subtype),
+                            }));
+                        }
+                        else {
+                            // Convert any unpacked TypeVarTuples into object instances. We don't
+                            // know anything more about them.
+                            nextReturnType = (0, typeUtils_1.mapSubtypes)(nextReturnType, (returnSubtype) => {
+                                if ((0, types_1.isTypeVar)(returnSubtype) && (0, types_1.isUnpackedTypeVarTuple)(returnSubtype)) {
+                                    return getObjectType();
+                                }
+                                return returnSubtype;
+                            });
+                            if (!isAsync) {
+                                return nextReturnType;
+                            }
+                            // If it's an async iteration, there's an implicit
+                            // 'await' operator applied.
+                            const awaitableResult = getTypeOfAwaitable({ type: nextReturnType, isIncomplete: typeResult.isIncomplete }, errorNode);
+                            if (awaitableResult.isIncomplete) {
+                                isIncomplete = true;
+                            }
+                            return awaitableResult.type;
+                        }
+                        return undefined;
+                    });
+                    if (iterReturnTypeDiag.isEmpty()) {
+                        return returnType;
+                    }
+                    diag.addAddendum(iterReturnTypeDiag);
+                }
+            }
+            if (!isIncomplete && emitNotIterableError) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeNotIterable().format({ type: printType(subtype) }) + diag.getString(), errorNode);
+            }
+            isValidIterator = false;
+            return undefined;
+        });
+        return isValidIterator ? { type: iterableType, isIncomplete } : undefined;
+    }
+    function getTypeOfIterable(typeResult, isAsync, errorNode, emitNotIterableError = true) {
+        const iterMethodName = isAsync ? '__aiter__' : '__iter__';
+        let isValidIterable = true;
+        let type = makeTopLevelTypeVarsConcrete(typeResult.type);
+        if ((0, typeUtils_1.isOptionalType)(type)) {
+            if (!typeResult.isIncomplete && emitNotIterableError) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOptionalIterable, localize_1.LocMessage.noneNotIterable(), errorNode);
+            }
+            type = (0, typeUtils_1.removeNoneFromUnion)(type);
+        }
+        const iterableType = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+            if ((0, types_1.isAnyOrUnknown)(subtype)) {
+                return subtype;
+            }
+            if ((0, types_1.isClass)(subtype)) {
+                const iterReturnType = getTypeOfMagicMethodCall(subtype, iterMethodName, [], errorNode)?.type;
+                if (iterReturnType) {
+                    return makeTopLevelTypeVarsConcrete(iterReturnType);
+                }
+            }
+            if (emitNotIterableError) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeNotIterable().format({ type: printType(subtype) }), errorNode);
+            }
+            isValidIterable = false;
+            return undefined;
+        });
+        return isValidIterable ? { type: iterableType, isIncomplete: typeResult.isIncomplete } : undefined;
+    }
+    function getTypeOfIndexedObjectOrClass(node, baseType, selfType, usage) {
+        // Handle index operations for TypedDict classes specially.
+        if ((0, types_1.isClassInstance)(baseType) && types_1.ClassType.isTypedDictClass(baseType)) {
+            const typeFromTypedDict = (0, typedDicts_1.getTypeOfIndexedTypedDict)(evaluatorInterface, node, baseType, usage);
+            if (typeFromTypedDict) {
+                return typeFromTypedDict;
+            }
+        }
+        const magicMethodName = getIndexAccessMagicMethodName(usage);
+        // A full member lookup specializes tuple arguments even if a constant
+        // index can select its answer directly.
+        const nativeItemSymbol = usage.method === 'get' && !selfType && (0, types_1.isClassInstance)(baseType) && types_1.ClassType.isBuiltIn(baseType, 'tuple')
+            ? types_1.ClassType.getSymbolTable(baseType).get(magicMethodName)
+            : undefined;
+        const nativeItemType = nativeItemSymbol?.isClassMember()
+            ? getEffectiveTypeOfSymbol(nativeItemSymbol)
+            : undefined;
+        const nativeItemMethods = nativeItemType && (0, types_1.isFunctionOrOverloaded)(nativeItemType)
+            ? (0, types_1.isOverloaded)(nativeItemType)
+                ? types_1.OverloadedType.getOverloads(nativeItemType)
+                : [nativeItemType]
+            : [];
+        const canDeferBinding = nativeItemMethods.length > 0 &&
+            nativeItemMethods.every((method) => types_1.FunctionType.isInstanceMethod(method) &&
+                method.shared.parameters.length > 0 &&
+                !types_1.FunctionParam.isTypeDeclared(method.shared.parameters[0]));
+        let itemMethodType = canDeferBinding
+            ? undefined
+            : getBoundMagicMethod(baseType, magicMethodName, selfType, node.d.leftExpr);
+        // Handle the special case where the object is a tuple and
+        // the index is a constant number (integer) or a slice with integer
+        // start and end values. In these cases, we can determine
+        // the exact type by indexing into the tuple type array.
+        if ((canDeferBinding || itemMethodType) &&
+            node.d.items.length === 1 &&
+            !node.d.trailingComma &&
+            !node.d.items[0].d.name &&
+            node.d.items[0].d.argCategory === 0 /* ArgCategory.Simple */ &&
+            (0, types_1.isClassInstance)(baseType)) {
+            const index0Expr = node.d.items[0].d.valueExpr;
+            const valueType = getTypeOfExpression(index0Expr).type;
+            if ((0, types_1.isClassInstance)(valueType) &&
+                types_1.ClassType.isBuiltIn(valueType, 'int') &&
+                (0, typeUtils_1.isLiteralType)(valueType) &&
+                typeof valueType.priv.literalValue === 'number') {
+                const indexValue = valueType.priv.literalValue;
+                const tupleType = (0, typeUtils_1.getSpecializedTupleType)(baseType);
+                if (tupleType && tupleType.priv.tupleTypeArgs) {
+                    if ((0, typeUtils_1.isTupleIndexUnambiguous)(tupleType, indexValue)) {
+                        if (indexValue >= 0 && indexValue < tupleType.priv.tupleTypeArgs.length) {
+                            return { type: tupleType.priv.tupleTypeArgs[indexValue].type };
+                        }
+                        else if (indexValue < 0 && tupleType.priv.tupleTypeArgs.length + indexValue >= 0) {
+                            return {
+                                type: tupleType.priv.tupleTypeArgs[tupleType.priv.tupleTypeArgs.length + indexValue]
+                                    .type,
+                            };
+                        }
+                    }
+                }
+            }
+            else if (usage.method === 'get' &&
+                index0Expr.nodeType === 46 /* ParseNodeType.Slice */ &&
+                (0, types_1.isClassInstance)(valueType) &&
+                types_1.ClassType.isBuiltIn(valueType, 'slice')) {
+                const tupleType = (0, typeUtils_1.getSpecializedTupleType)(baseType);
+                if (tupleType) {
+                    // Skip this if a subclass overrides the tuple's __getitem__ method.
+                    const getItemMember = (0, typeUtils_1.lookUpObjectMember)(baseType, '__getitem__', 16 /* MemberAccessFlags.SkipInstanceMembers */);
+                    const isTupleGetItem = !getItemMember ||
+                        ((0, types_1.isInstantiableClass)(getItemMember.classType) &&
+                            types_1.ClassType.isBuiltIn(getItemMember.classType, 'tuple'));
+                    if (isTupleGetItem) {
+                        const slicedTupleType = (0, tuples_1.getSlicedTupleType)(evaluatorInterface, tupleType, index0Expr);
+                        if (slicedTupleType) {
+                            return { type: slicedTupleType };
+                        }
+                    }
+                }
+            }
+        }
+        if (canDeferBinding) {
+            const inferredBase = (0, types_1.getInferredTupleLiteralBase)(baseType);
+            const tupleArgs = baseType.priv.tupleTypeArgs;
+            if (inferredBase !== baseType &&
+                (0, types_1.isClassInstance)(inferredBase) &&
+                types_1.ClassType.isBuiltIn(inferredBase, 'tuple') &&
+                tupleArgs &&
+                tupleArgs.length > 1 &&
+                tupleArgs.some((arg) => (0, types_1.isUnion)(arg.type) || ((0, types_1.isClassInstance)(arg.type) && types_1.ClassType.isBuiltIn(arg.type, 'tuple')))) {
+                // Avoid structural union work for optional literals before native method binding.
+                baseType = inferredBase;
+            }
+            itemMethodType = getBoundMagicMethod(baseType, magicMethodName, selfType, node.d.leftExpr);
+        }
+        if (!itemMethodType) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIndexIssue, localize_1.LocMessage.methodNotDefinedOnType().format({
+                name: magicMethodName,
+                type: printType(baseType),
+            }), node.d.leftExpr);
+            return { type: types_1.UnknownType.create() };
+        }
+        const positionalArgs = node.d.items.filter((item) => item.d.argCategory === 0 /* ArgCategory.Simple */);
+        const unpackedListArgs = node.d.items.filter((item) => item.d.argCategory === 1 /* ArgCategory.UnpackedList */);
+        let positionalIndexType;
+        let isPositionalIndexTypeIncomplete = false;
+        if (positionalArgs.length === 1 && unpackedListArgs.length === 0 && !node.d.trailingComma) {
+            // Handle the common case where there is a single positional argument.
+            const typeResult = getTypeOfExpression(positionalArgs[0].d.valueExpr);
+            positionalIndexType = typeResult.type;
+            if (typeResult.isIncomplete) {
+                isPositionalIndexTypeIncomplete = true;
+            }
+        }
+        else {
+            // Package up all of the positionals into a tuple.
+            const tupleTypeArgs = [];
+            const getDeterministicTupleEntries = (type) => {
+                let aggregatedArgs;
+                let isDeterministic = true;
+                (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+                    if (!isDeterministic) {
+                        return;
+                    }
+                    const tupleType = (0, typeUtils_1.getSpecializedTupleType)(subtype);
+                    const tupleTypeArgs = tupleType?.priv.tupleTypeArgs;
+                    if (!tupleTypeArgs ||
+                        tupleTypeArgs.some((entry) => entry.isUnbounded || (0, types_1.isTypeVarTuple)(entry.type))) {
+                        isDeterministic = false;
+                        return;
+                    }
+                    if (!aggregatedArgs) {
+                        aggregatedArgs = tupleTypeArgs.map((entry) => ({ type: entry.type, isUnbounded: false }));
+                        return;
+                    }
+                    if (aggregatedArgs.length !== tupleTypeArgs.length) {
+                        isDeterministic = false;
+                        return;
+                    }
+                    for (let i = 0; i < aggregatedArgs.length; i++) {
+                        aggregatedArgs[i] = {
+                            type: (0, types_1.combineTypes)([aggregatedArgs[i].type, tupleTypeArgs[i].type]),
+                            isUnbounded: false,
+                        };
+                    }
+                });
+                if (!isDeterministic || !aggregatedArgs) {
+                    return undefined;
+                }
+                return aggregatedArgs;
+            };
+            node.d.items.forEach((arg) => {
+                if (arg.d.argCategory === 0 /* ArgCategory.Simple */) {
+                    const typeResult = getTypeOfExpression(arg.d.valueExpr);
+                    tupleTypeArgs.push({ type: typeResult.type, isUnbounded: false });
+                    if (typeResult.isIncomplete) {
+                        isPositionalIndexTypeIncomplete = true;
+                    }
+                    return;
+                }
+                if (arg.d.argCategory === 1 /* ArgCategory.UnpackedList */) {
+                    const typeResult = getTypeOfExpression(arg.d.valueExpr);
+                    if (typeResult.isIncomplete) {
+                        isPositionalIndexTypeIncomplete = true;
+                    }
+                    const deterministicEntries = getDeterministicTupleEntries(typeResult.type);
+                    if (deterministicEntries) {
+                        (0, collectionUtils_1.appendArray)(tupleTypeArgs, deterministicEntries);
+                        return;
+                    }
+                    const iterableType = getTypeOfIterator(typeResult, /* isAsync */ false, arg.d.valueExpr)?.type ??
+                        types_1.UnknownType.create();
+                    tupleTypeArgs.push({ type: iterableType, isUnbounded: true });
+                }
+            });
+            const unboundedCount = tupleTypeArgs.filter((typeArg) => typeArg.isUnbounded).length;
+            if (unboundedCount > 1) {
+                const firstUnboundedIndex = tupleTypeArgs.findIndex((typeArg) => typeArg.isUnbounded);
+                const removedEntries = tupleTypeArgs.splice(firstUnboundedIndex);
+                tupleTypeArgs.push({
+                    type: (0, types_1.combineTypes)(removedEntries.map((entry) => entry.type)),
+                    isUnbounded: true,
+                });
+            }
+            positionalIndexType = (0, tuples_1.makeTupleObject)(evaluatorInterface, tupleTypeArgs);
+        }
+        const argList = [
+            {
+                argCategory: 0 /* ArgCategory.Simple */,
+                typeResult: { type: positionalIndexType, isIncomplete: isPositionalIndexTypeIncomplete },
+            },
+        ];
+        if (usage.method === 'set') {
+            let setType = usage.setType?.type ?? types_1.AnyType.create();
+            // Expand constrained type variables.
+            if ((0, types_1.isTypeVar)(setType) && types_1.TypeVarType.hasConstraints(setType)) {
+                const conditionFilter = (0, types_1.isClassInstance)(baseType) ? baseType.props?.condition : undefined;
+                setType = makeTopLevelTypeVarsConcrete(setType, 
+                /* makeParamSpecsConcrete */ undefined, conditionFilter);
+            }
+            argList.push({
+                argCategory: 0 /* ArgCategory.Simple */,
+                typeResult: {
+                    type: setType,
+                    isIncomplete: !!usage.setType?.isIncomplete,
+                },
+            });
+        }
+        const callResult = validateCallArgs(node, argList, { type: itemMethodType }, 
+        /* constraints */ undefined, 
+        /* skipUnknownArgCheck */ true, 
+        /* inferenceContext */ undefined);
+        return {
+            type: callResult.returnType ?? types_1.UnknownType.create(),
+            isIncomplete: !!callResult.isTypeIncomplete,
+        };
+    }
+    function getTypeArg(node, flags, supportsDictExpression) {
+        let typeResult;
+        let adjustedFlags = flags | 128 /* EvalFlags.InstantiableType */ | 1 /* EvalFlags.ConvertEllipsisToAny */ | 8 /* EvalFlags.StrLiteralAsType */;
+        const fileInfo = nodeInfo.getFileInfo(node);
+        if (fileInfo.isStubFile) {
+            adjustedFlags |= 4 /* EvalFlags.ForwardRefs */;
+        }
+        if (node.nodeType === 34 /* ParseNodeType.List */) {
+            typeResult = {
+                type: types_1.UnknownType.create(),
+                typeList: node.d.items.map((entry) => {
+                    return { ...getTypeOfExpression(entry, adjustedFlags), node: entry };
+                }),
+                node,
+            };
+            // Set the node's type so it isn't reevaluated later.
+            setTypeResultForNode(node, { type: types_1.UnknownType.create() });
+        }
+        else if (node.nodeType === 18 /* ParseNodeType.Dictionary */ && supportsDictExpression) {
+            const inlinedTypeDict = context.prefetched?.typedDictClass && (0, types_1.isInstantiableClass)(context.prefetched.typedDictClass)
+                ? (0, typedDicts_1.createTypedDictTypeInlined)(evaluatorInterface, node, context.prefetched.typedDictClass, nodeInfo)
+                : undefined;
+            const keyTypeFallback = context.prefetched?.strClass && (0, types_1.isInstantiableClass)(context.prefetched.strClass)
+                ? context.prefetched.strClass
+                : types_1.UnknownType.create();
+            typeResult = {
+                type: keyTypeFallback,
+                inlinedTypeDict,
+                node,
+            };
+        }
+        else {
+            typeResult = { ...getTypeOfExpression(node, adjustedFlags), node };
+            if (node.nodeType === 18 /* ParseNodeType.Dictionary */) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.dictInAnnotation(), node);
+            }
+            if ((flags & 131072 /* EvalFlags.NoClassVar */) !== 0) {
+                // "ClassVar" is not allowed as a type argument.
+                if ((0, types_1.isClass)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, 'ClassVar')) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.classVarNotAllowed(), node);
+                }
+            }
+        }
+        return typeResult;
+    }
+    function getTypeOfLambdaForCall(node, inferenceContext) {
+        (0, debug_1.assert)(node.d.leftExpr.nodeType === 33 /* ParseNodeType.Lambda */);
+        const expectedType = types_1.FunctionType.createSynthesizedInstance('');
+        expectedType.shared.declaredReturnType = inferenceContext
+            ? inferenceContext.expectedType
+            : types_1.UnknownType.create();
+        let isArgTypeIncomplete = false;
+        node.d.args.forEach((arg, index) => {
+            const argTypeResult = getTypeOfExpression(arg.d.valueExpr);
+            if (argTypeResult.isIncomplete) {
+                isArgTypeIncomplete = true;
+            }
+            types_1.FunctionType.addParam(expectedType, types_1.FunctionParam.create(0 /* ParamCategory.Simple */, argTypeResult.type, types_1.FunctionParamFlags.NameSynthesized | types_1.FunctionParamFlags.TypeDeclared, `p${index.toString()}`));
+        });
+        // If the lambda's param list ends with a "/" positional parameter separator,
+        // add a corresponding separator to the expected type.
+        const lambdaParams = node.d.leftExpr.d.params;
+        if (lambdaParams.length > 0) {
+            const lastParam = lambdaParams[lambdaParams.length - 1];
+            if (lastParam.d.category === 0 /* ParamCategory.Simple */ && !lastParam.d.name) {
+                types_1.FunctionType.addPositionOnlyParamSeparator(expectedType);
+            }
+        }
+        function getLambdaType() {
+            return getTypeOfExpression(node.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */, (0, typeUtils_1.makeInferenceContext)(expectedType));
+        }
+        // If one or more of the arguments are incomplete, use speculative mode
+        // for the lambda evaluation because it may need to be reevaluated once
+        // the arg types are complete.
+        let typeResult = isArgTypeIncomplete || isSpeculativeModeInUse(node) || inferenceContext?.isTypeIncomplete
+            ? useSpeculativeMode(node.d.leftExpr, getLambdaType)
+            : getLambdaType();
+        // If bidirectional type inference failed, use normal type inference instead.
+        if (typeResult.typeErrors) {
+            typeResult = getTypeOfExpression(node.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
+        }
+        return typeResult;
+    }
+    function getTypeOfTypeForm(node, typeFormClass) {
+        if (node.d.args.length !== 1 ||
+            node.d.args[0].d.argCategory !== 0 /* ArgCategory.Simple */ ||
+            node.d.args[0].d.name !== undefined) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeFormArgs(), node);
+            return { type: types_1.UnknownType.create() };
+        }
+        const typeFormResult = getTypeOfArgExpectingType(convertNodeToArg(node.d.args[0]), {
+            typeFormArg: true,
+            noNonTypeSpecialForms: true,
+            typeExpression: true,
+        });
+        if (!typeFormResult.typeErrors && typeFormResult.type.props?.typeForm) {
+            typeFormResult.type = (0, typeUtils_1.convertToInstance)(types_1.ClassType.specialize(typeFormClass, [(0, typeUtils_1.convertToInstance)(typeFormResult.type.props.typeForm)]));
+        }
+        return typeFormResult;
+    }
+    function getTypeOfAssertType(node, inferenceContext) {
+        if (node.d.args.length !== 2 ||
+            node.d.args[0].d.argCategory !== 0 /* ArgCategory.Simple */ ||
+            node.d.args[0].d.name !== undefined ||
+            node.d.args[0].d.argCategory !== 0 /* ArgCategory.Simple */ ||
+            node.d.args[1].d.name !== undefined) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.assertTypeArgs(), node);
+            return { type: types_1.UnknownType.create() };
+        }
+        const arg0TypeResult = getTypeOfExpression(node.d.args[0].d.valueExpr, /* flags */ undefined, inferenceContext);
+        if (arg0TypeResult.isIncomplete) {
+            return { type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
+        }
+        const assertedType = (0, typeUtils_1.convertToInstance)(getTypeOfArgExpectingType(convertNodeToArg(node.d.args[1]), {
+            typeExpression: true,
+        }).type);
+        // We'll replace TypeGuard and TypeIs with bool for purposes of assert_type testing.
+        // The spec is unclear on whether this is the correct behavior, but it seems to be
+        // what mypy does -- and what various library authors expect.
+        const arg0Type = stripTypeGuard(arg0TypeResult.type);
+        const typeSameOptions = {
+            treatAnySameAsUnknown: true,
+            ignorePseudoGeneric: true,
+            ignoreConditions: true,
+        };
+        let typesMatch = (0, types_1.isTypeSame)(assertedType, arg0Type, typeSameOptions);
+        if (!typesMatch) {
+            // Unlike assignType, assert_type requires exact structural identity, so
+            // normalize both types recursively. Keep this equivalence relation aligned
+            // with expandEnumTypeForLiteralComparison, which assignType applies as it recurses.
+            const literalEnumClasses = collectLiteralEnumClasses(assertedType, [], /* recursively */ true);
+            collectLiteralEnumClasses(arg0Type, literalEnumClasses, /* recursively */ true);
+            const normalizedAssertedType = normalizeEnumTypes(assertedType, literalEnumClasses);
+            const normalizedArg0Type = normalizeEnumTypes(arg0Type, literalEnumClasses);
+            typesMatch = (0, types_1.isTypeSame)(normalizedAssertedType, normalizedArg0Type, typeSameOptions);
+        }
+        if (!typesMatch) {
+            const srcDestTypes = printSrcDestTypes(arg0TypeResult.type, assertedType, { expandTypeAlias: true });
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, localize_1.LocMessage.assertTypeTypeMismatch().format({
+                expected: srcDestTypes.destType,
+                received: srcDestTypes.sourceType,
+            }), node.d.args[0].d.valueExpr);
+        }
+        return { type: arg0TypeResult.type };
+    }
+    function getTypeOfRevealLocals(node) {
+        let curNode = node;
+        let scope;
+        while (curNode) {
+            scope = getScopeForNode(curNode);
+            // Stop when we get a valid scope that's not a list comprehension
+            // scope. That includes lambdas, functions, classes, and modules.
+            if (scope && scope.type !== 1 /* ScopeType.Comprehension */) {
+                break;
+            }
+            curNode = curNode.parent;
+        }
+        const infoMessages = [];
+        if (scope) {
+            scope.symbolTable.forEach((symbol, name) => {
+                if (!symbol.isIgnoredForProtocolMatch()) {
+                    const typeOfSymbol = getEffectiveTypeOfSymbol(symbol);
+                    infoMessages.push(localize_1.LocAddendum.typeOfSymbol().format({
+                        name,
+                        type: printType(typeOfSymbol, { expandTypeAlias: true }),
+                    }));
+                }
+            });
+        }
+        if (infoMessages.length > 0) {
+            addInformation(infoMessages.join('\n'), node);
+        }
+        else {
+            addInformation(localize_1.LocMessage.revealLocalsNone(), node);
+        }
+        return getNoneType();
+    }
+    function getTypeOfSuperCall(node) {
+        if (node.d.args.length > 2) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.superCallArgCount(), node.d.args[2]);
+        }
+        const enclosingFunction = ParseTreeUtils.getEnclosingFunctionEvaluationScope(node, nodeInfo);
+        const enclosingClass = enclosingFunction ? ParseTreeUtils.getEnclosingClass(enclosingFunction) : undefined;
+        const enclosingClassType = enclosingClass ? getTypeOfClass(enclosingClass)?.classType : undefined;
+        // Determine which class the "super" call is applied to. If
+        // there is no first argument, then the class is implicit.
+        let targetClassType;
+        if (node.d.args.length > 0) {
+            targetClassType = getTypeOfExpression(node.d.args[0].d.valueExpr).type;
+            const concreteTargetClassType = makeTopLevelTypeVarsConcrete(targetClassType);
+            if (!(0, types_1.isAnyOrUnknown)(concreteTargetClassType) &&
+                !(0, types_1.isInstantiableClass)(concreteTargetClassType) &&
+                !(0, typeUtils_1.isMetaclassInstance)(concreteTargetClassType)) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, localize_1.LocMessage.superCallFirstArg().format({ type: printType(targetClassType) }), node.d.args[0].d.valueExpr);
+            }
+        }
+        else {
+            if (enclosingClassType) {
+                targetClassType = enclosingClassType ?? types_1.UnknownType.create();
+                const functionInfo = enclosingFunction
+                    ? (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, enclosingFunction, 
+                    /* isInClass */ true, nodeInfo)
+                    : undefined;
+                // Zero-argument forms of super are not allowed within static methods.
+                // This results in a runtime exception.
+                if (functionInfo !== undefined && (functionInfo.flags & 4 /* FunctionTypeFlags.StaticMethod */) !== 0) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.superCallZeroArgFormStaticMethod(), node.d.leftExpr);
+                }
+                else if (!ParseTreeUtils.isZeroArgSuperCallAllowed(node, nodeInfo.getFileInfo(node).executionEnvironment.pythonVersion, nodeInfo)) {
+                    // The evaluation scope cannot supply a first positional
+                    // argument for the zero-argument form.
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.superCallZeroArgForm(), node.d.leftExpr);
+                }
+            }
+            else {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.superCallZeroArgForm(), node.d.leftExpr);
+                targetClassType = types_1.UnknownType.create();
+            }
+        }
+        const concreteTargetClassType = makeTopLevelTypeVarsConcrete(targetClassType);
+        // Determine whether to further narrow the type.
+        let secondArgType;
+        let bindToType;
+        if (node.d.args.length > 1) {
+            secondArgType = getTypeOfExpression(node.d.args[1].d.valueExpr).type;
+            const secondArgConcreteType = makeTopLevelTypeVarsConcrete(secondArgType);
+            let reportError = false;
+            (0, typeUtils_1.doForEachSubtype)(secondArgConcreteType, (secondArgSubtype) => {
+                if ((0, types_1.isAnyOrUnknown)(secondArgSubtype)) {
+                    // Ignore unknown or any types.
+                }
+                else if ((0, types_1.isClassInstance)(secondArgSubtype)) {
+                    if ((0, types_1.isInstantiableClass)(concreteTargetClassType)) {
+                        if (!(0, typeUtils_1.derivesFromClassRecursive)(types_1.ClassType.cloneAsInstantiable(secondArgSubtype), concreteTargetClassType, 
+                        /* ignoreUnknown */ true)) {
+                            reportError = true;
+                        }
+                    }
+                    bindToType = secondArgSubtype;
+                }
+                else if ((0, types_1.isInstantiableClass)(secondArgSubtype)) {
+                    if ((0, types_1.isInstantiableClass)(concreteTargetClassType)) {
+                        if (!types_1.ClassType.isBuiltIn(concreteTargetClassType, 'type') &&
+                            !(0, typeUtils_1.derivesFromClassRecursive)(secondArgSubtype, concreteTargetClassType, 
+                            /* ignoreUnknown */ true)) {
+                            reportError = true;
+                        }
+                    }
+                    bindToType = secondArgSubtype;
+                }
+                else {
+                    reportError = true;
+                }
+            });
+            if (reportError) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, localize_1.LocMessage.superCallSecondArg().format({ type: printType(targetClassType) }), node.d.args[1].d.valueExpr);
+                return { type: types_1.UnknownType.create() };
+            }
+        }
+        else if (enclosingClassType) {
+            bindToType = types_1.ClassType.cloneAsInstance(enclosingClassType);
+            // Get the type from the self or cls parameter if it is explicitly annotated.
+            // If it's a TypeVar, change the bindToType into a conditional type.
+            const enclosingMethod = ParseTreeUtils.getEnclosingFunction(node);
+            let implicitBindToType;
+            if (enclosingMethod) {
+                const methodTypeInfo = getTypeOfFunction(enclosingMethod);
+                if (methodTypeInfo) {
+                    const methodType = methodTypeInfo.functionType;
+                    if (types_1.FunctionType.isClassMethod(methodType) ||
+                        types_1.FunctionType.isConstructorMethod(methodType) ||
+                        types_1.FunctionType.isInstanceMethod(methodType)) {
+                        if (methodType.shared.parameters.length > 0 &&
+                            types_1.FunctionParam.isTypeDeclared(methodType.shared.parameters[0])) {
+                            let paramType = types_1.FunctionType.getParamType(methodType, 0);
+                            const liveScopeIds = getTypeVarScopesForNode(node);
+                            paramType = (0, typeUtils_1.makeTypeVarsBound)(paramType, liveScopeIds);
+                            implicitBindToType = makeTopLevelTypeVarsConcrete(paramType);
+                        }
+                    }
+                }
+            }
+            if (bindToType && implicitBindToType) {
+                const typeCondition = (0, typeUtils_1.getTypeCondition)(implicitBindToType);
+                if (typeCondition) {
+                    bindToType = (0, typeUtils_1.addConditionToType)(bindToType, typeCondition);
+                }
+                else if ((0, types_1.isClass)(implicitBindToType)) {
+                    bindToType = implicitBindToType;
+                }
+            }
+        }
+        // Determine whether super() should return an instance of the class or
+        // the class itself. It depends on whether the super() call is located
+        // within an instance method or not.
+        let resultIsInstance = true;
+        if (node.d.args.length <= 1) {
+            const enclosingMethod = ParseTreeUtils.getEnclosingFunction(node);
+            if (enclosingMethod) {
+                const methodType = getTypeOfFunction(enclosingMethod);
+                if (methodType) {
+                    if (types_1.FunctionType.isStaticMethod(methodType.functionType) ||
+                        types_1.FunctionType.isConstructorMethod(methodType.functionType) ||
+                        types_1.FunctionType.isClassMethod(methodType.functionType)) {
+                        resultIsInstance = false;
+                    }
+                }
+            }
+        }
+        // Python docs indicate that super() isn't valid for
+        // operations other than member accesses or attribute lookups.
+        const parentNode = node.parent;
+        if (parentNode?.nodeType === 35 /* ParseNodeType.MemberAccess */) {
+            const memberName = parentNode.d.member.d.value;
+            let effectiveTargetClass = (0, types_1.isClass)(concreteTargetClassType) ? concreteTargetClassType : undefined;
+            // If the bind-to type is a protocol, don't use the effective target class.
+            // This pattern is used for mixins, where the mixin type is a protocol class
+            // that is used to decorate the "self" or "cls" parameter.
+            let isProtocolClass = false;
+            if (bindToType &&
+                types_1.ClassType.isProtocolClass(bindToType) &&
+                effectiveTargetClass &&
+                !types_1.ClassType.isSameGenericClass(types_1.TypeBase.isInstance(bindToType) ? types_1.ClassType.cloneAsInstantiable(bindToType) : bindToType, effectiveTargetClass)) {
+                isProtocolClass = true;
+                effectiveTargetClass = undefined;
+            }
+            if (bindToType) {
+                bindToType = (0, typeUtils_1.selfSpecializeClass)(bindToType, { useBoundTypeVars: true });
+            }
+            const lookupResults = bindToType
+                ? (0, typeUtils_1.lookUpClassMember)(bindToType, memberName, 0 /* MemberAccessFlags.Default */, effectiveTargetClass)
+                : undefined;
+            let resultType;
+            if (lookupResults && (0, types_1.isInstantiableClass)(lookupResults.classType)) {
+                resultType = lookupResults.classType;
+                if (isProtocolClass) {
+                    // If the bindToType is a protocol class, set the "include subclasses" flag
+                    // so we don't enforce that called methods are implemented within the protocol.
+                    resultType = types_1.ClassType.cloneIncludeSubclasses(resultType);
+                }
+            }
+            else if (effectiveTargetClass &&
+                !(0, types_1.isAnyOrUnknown)(effectiveTargetClass) &&
+                !(0, typeUtils_1.derivesFromAnyOrUnknown)(effectiveTargetClass)) {
+                resultType = context.prefetched?.objectClass ?? types_1.UnknownType.create();
+            }
+            else {
+                resultType = types_1.UnknownType.create();
+            }
+            let bindToSelfType;
+            if (bindToType) {
+                if (secondArgType) {
+                    // If a TypeVar was passed as the second argument, use it
+                    // to derive the the self type.
+                    if ((0, types_1.isTypeVar)(secondArgType)) {
+                        bindToSelfType = (0, typeUtils_1.convertToInstance)(secondArgType);
+                    }
+                }
+                else {
+                    // If this is a zero-argument form of super(), synthesize
+                    // a Self type to bind to.
+                    bindToSelfType = types_1.TypeBase.cloneForCondition(types_1.TypeVarType.cloneAsBound((0, typeUtils_1.synthesizeTypeVarForSelfCls)(types_1.ClassType.cloneIncludeSubclasses(bindToType, /* includeSubclasses */ false), 
+                    /* isClsParam */ false)), bindToType.props?.condition);
+                }
+            }
+            const type = resultIsInstance ? (0, typeUtils_1.convertToInstance)(resultType, /* includeSubclasses */ false) : resultType;
+            return { type, bindToSelfType };
+        }
+        // Handle the super() call when used outside of a member access expression.
+        if ((0, types_1.isInstantiableClass)(concreteTargetClassType)) {
+            // We don't know which member is going to be accessed, so we cannot
+            // deterministically determine the correct type in this case. We'll
+            // use a heuristic that produces the "correct" (desired) behavior in
+            // most cases. If there's a bindToType and the targetClassType is one
+            // of the base classes of the bindToType, we'll return the next base
+            // class.
+            if (bindToType) {
+                let nextBaseClassType;
+                if (types_1.ClassType.isSameGenericClass(types_1.TypeBase.isInstance(bindToType) ? types_1.ClassType.cloneAsInstantiable(bindToType) : bindToType, concreteTargetClassType)) {
+                    if (bindToType.shared.baseClasses.length > 0) {
+                        nextBaseClassType = bindToType.shared.baseClasses[0];
+                    }
+                }
+                else {
+                    const baseClassIndex = bindToType.shared.baseClasses.findIndex((baseClass) => (0, types_1.isClass)(baseClass) &&
+                        types_1.ClassType.isSameGenericClass(baseClass, concreteTargetClassType));
+                    if (baseClassIndex >= 0 && baseClassIndex < bindToType.shared.baseClasses.length - 1) {
+                        nextBaseClassType = bindToType.shared.baseClasses[baseClassIndex + 1];
+                    }
+                }
+                if (nextBaseClassType) {
+                    if ((0, types_1.isInstantiableClass)(nextBaseClassType)) {
+                        nextBaseClassType = (0, typeUtils_1.specializeForBaseClass)(bindToType, nextBaseClassType);
+                    }
+                    return { type: resultIsInstance ? (0, typeUtils_1.convertToInstance)(nextBaseClassType) : nextBaseClassType };
+                }
+                // There's not much we can say about the type. Simply return object or type.
+                if (context.prefetched?.typeClass && (0, types_1.isInstantiableClass)(context.prefetched.typeClass)) {
+                    return {
+                        type: resultIsInstance ? getObjectType() : (0, typeUtils_1.convertToInstance)(context.prefetched.typeClass),
+                    };
+                }
+            }
+            else {
+                // If the class derives from one or more unknown classes,
+                // return unknown here to prevent spurious errors.
+                if (concreteTargetClassType.shared.mro.some((mroBase) => (0, types_1.isAnyOrUnknown)(mroBase))) {
+                    return { type: types_1.UnknownType.create() };
+                }
+                const baseClasses = concreteTargetClassType.shared.baseClasses;
+                if (baseClasses.length > 0) {
+                    const baseClassType = baseClasses[0];
+                    if ((0, types_1.isInstantiableClass)(baseClassType)) {
+                        return {
+                            type: resultIsInstance ? types_1.ClassType.cloneAsInstance(baseClassType) : baseClassType,
+                        };
+                    }
+                }
+            }
+        }
+        return { type: types_1.UnknownType.create() };
+    }
+    function evaluateCastCall(argList, errorNode) {
+        if (argList[0].argCategory !== 0 /* ArgCategory.Simple */ && argList[0].valueExpression) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackInAnnotation(), argList[0].valueExpression);
+        }
+        // Verify that the cast is necessary.
+        let castToType = getTypeOfArgExpectingType(argList[0], { typeExpression: true }).type;
+        const liveScopeIds = getTypeVarScopesForNode(errorNode);
+        castToType = (0, typeUtils_1.makeTypeVarsBound)(castToType, liveScopeIds);
+        let castFromType = getTypeOfArg(argList[1], /* inferenceContext */ undefined).type;
+        if (castFromType.props?.specialForm) {
+            castFromType = castFromType.props.specialForm;
+        }
+        if (types_1.TypeBase.isInstantiable(castToType) && !(0, types_1.isUnknown)(castToType)) {
+            if ((0, types_1.isTypeSame)((0, typeUtils_1.convertToInstance)(castToType), castFromType, {
+                ignorePseudoGeneric: true,
+            })) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnnecessaryCast, localize_1.LocMessage.unnecessaryCast().format({
+                    type: printType(castFromType),
+                }), errorNode);
+            }
+        }
+        return (0, typeUtils_1.convertToInstance)(castToType);
+    }
+    function getTypeOfConstant(node, flags) {
+        let type;
+        if (node.d.constType === 27 /* KeywordType.None */) {
+            if (context.prefetched?.noneTypeClass) {
+                type =
+                    (flags & 128 /* EvalFlags.InstantiableType */) !== 0
+                        ? context.prefetched.noneTypeClass
+                        : (0, typeUtils_1.convertToInstance)(context.prefetched.noneTypeClass);
+                type = types_1.TypeBase.cloneWithTypeForm(type, (0, typeUtils_1.convertToInstance)(type));
+            }
+        }
+        else if (node.d.constType === 34 /* KeywordType.True */ ||
+            node.d.constType === 15 /* KeywordType.False */ ||
+            node.d.constType === 9 /* KeywordType.Debug */) {
+            type = getBuiltInObject(node, 'bool');
+            // For True and False, we can create truthy and falsy
+            // versions of 'bool'.
+            if (type && (0, types_1.isClassInstance)(type)) {
+                if (node.d.constType === 34 /* KeywordType.True */) {
+                    type = types_1.ClassType.cloneWithLiteral(type, /* value */ true);
+                }
+                else if (node.d.constType === 15 /* KeywordType.False */) {
+                    type = types_1.ClassType.cloneWithLiteral(type, /* value */ false);
+                }
+            }
+        }
+        return { type: type ?? types_1.UnknownType.create() };
+    }
+    function getTypeOfMagicMethodCall(objType, methodName, argList, errorNode, inferenceContext, diag) {
+        let magicMethodSupported = true;
+        let isIncomplete = false;
+        let deprecationInfo;
+        const overloadsUsedForCall = [];
+        // Create a helper lambda for object subtypes.
+        const handleSubtype = (subtype) => {
+            let magicMethodType;
+            const concreteSubtype = makeTopLevelTypeVarsConcrete(subtype);
+            if ((0, types_1.isClass)(concreteSubtype)) {
+                magicMethodType = getBoundMagicMethod(concreteSubtype, methodName, subtype, errorNode, diag);
+            }
+            if (magicMethodType) {
+                const functionArgs = argList.map((arg) => {
+                    return {
+                        argCategory: 0 /* ArgCategory.Simple */,
+                        typeResult: arg,
+                    };
+                });
+                let callResult;
+                callResult = useSpeculativeMode(errorNode, () => {
+                    (0, debug_1.assert)(magicMethodType !== undefined);
+                    return validateCallArgs(errorNode, functionArgs, { type: magicMethodType }, 
+                    /* constraints */ undefined, 
+                    /* skipUnknownArgCheck */ true, inferenceContext);
+                });
+                // If there were errors with the expected type, try
+                // to evaluate without the expected type.
+                if (callResult.argumentErrors && inferenceContext) {
+                    callResult = useSpeculativeMode(errorNode, () => {
+                        (0, debug_1.assert)(magicMethodType !== undefined);
+                        return validateCallArgs(errorNode, functionArgs, { type: magicMethodType }, 
+                        /* constraints */ undefined, 
+                        /* skipUnknownArgCheck */ true, 
+                        /* inferenceContext */ undefined);
+                    });
+                }
+                if (callResult.argumentErrors) {
+                    magicMethodSupported = false;
+                }
+                else if (callResult.overloadsUsedForCall) {
+                    callResult.overloadsUsedForCall.forEach((overload) => {
+                        overloadsUsedForCall.push(overload);
+                        // If one of the overloads is deprecated, note the message.
+                        if (overload.shared.deprecatedMessage && (0, types_1.isClass)(concreteSubtype)) {
+                            deprecationInfo = {
+                                deprecatedMessage: overload.shared.deprecatedMessage,
+                                className: concreteSubtype.shared.name,
+                                methodName,
+                            };
+                        }
+                    });
+                }
+                if (callResult.isTypeIncomplete) {
+                    isIncomplete = true;
+                }
+                return callResult.returnType;
+            }
+            magicMethodSupported = false;
+            return undefined;
+        };
+        const returnType = (0, typeUtils_1.mapSubtypes)(objType, (subtype) => {
+            if ((0, types_1.isAnyOrUnknown)(subtype)) {
+                return subtype;
+            }
+            if ((0, types_1.isClassInstance)(subtype) || (0, types_1.isInstantiableClass)(subtype) || (0, types_1.isTypeVar)(subtype)) {
+                return handleSubtype(subtype);
+            }
+            if ((0, typeUtils_1.isNoneInstance)(subtype)) {
+                if (context.prefetched?.objectClass && (0, types_1.isInstantiableClass)(context.prefetched.objectClass)) {
+                    // Use 'object' for 'None'.
+                    return handleSubtype(types_1.ClassType.cloneAsInstance(context.prefetched.objectClass));
+                }
+            }
+            if ((0, typeUtils_1.isNoneTypeClass)(subtype)) {
+                if (context.prefetched?.typeClass && (0, types_1.isInstantiableClass)(context.prefetched.typeClass)) {
+                    // Use 'type' for 'type[None]'.
+                    return handleSubtype(types_1.ClassType.cloneAsInstance(context.prefetched.typeClass));
+                }
+            }
+            magicMethodSupported = false;
+            return undefined;
+        });
+        if (!magicMethodSupported) {
+            return undefined;
+        }
+        return { type: returnType, isIncomplete, magicMethodDeprecationInfo: deprecationInfo, overloadsUsedForCall };
+    }
+    function getTypeOfYield(node) {
+        let expectedYieldType;
+        let sentType;
+        let isIncomplete = false;
+        const enclosingFunction = ParseTreeUtils.getEnclosingFunction(node);
+        if (enclosingFunction) {
+            const functionTypeInfo = getTypeOfFunction(enclosingFunction);
+            if (functionTypeInfo) {
+                let returnType = types_1.FunctionType.getEffectiveReturnType(functionTypeInfo.functionType);
+                if (returnType) {
+                    const liveScopeIds = getTypeVarScopesForNode(node);
+                    returnType = (0, typeUtils_1.makeTypeVarsBound)(returnType, liveScopeIds);
+                    expectedYieldType = (0, typeUtils_1.getGeneratorYieldType)(returnType, !!enclosingFunction.d.isAsync);
+                    const generatorTypeArgs = (0, typeUtils_1.getGeneratorTypeArgs)(returnType);
+                    if (generatorTypeArgs && generatorTypeArgs.length >= 2) {
+                        sentType = (0, typeUtils_1.makeTypeVarsBound)(generatorTypeArgs[1], liveScopeIds);
+                    }
+                }
+            }
+        }
+        if (node.d.expr) {
+            const exprResult = getTypeOfExpression(node.d.expr, 
+            /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedYieldType));
+            if (exprResult.isIncomplete) {
+                isIncomplete = true;
+            }
+        }
+        return { type: sentType || types_1.UnknownType.create(), isIncomplete };
+    }
+    function getTypeOfYieldFrom(node) {
+        const yieldFromTypeResult = getTypeOfExpression(node.d.expr);
+        const yieldFromType = yieldFromTypeResult.type;
+        const returnedType = (0, typeUtils_1.mapSubtypes)(yieldFromType, (yieldFromSubtype) => {
+            // Is the expression a Generator type?
+            let generatorTypeArgs = (0, typeUtils_1.getGeneratorTypeArgs)(yieldFromSubtype);
+            if (generatorTypeArgs) {
+                return generatorTypeArgs.length >= 2 ? generatorTypeArgs[2] : types_1.UnknownType.create();
+            }
+            // Handle old-style (pre-await) Coroutines as a special case.
+            if ((0, types_1.isClassInstance)(yieldFromSubtype) &&
+                types_1.ClassType.isBuiltIn(yieldFromSubtype, ['Coroutine', 'CoroutineType'])) {
+                return types_1.UnknownType.create();
+            }
+            // Handle simple iterables.
+            const iterableType = getTypeOfIterable(yieldFromTypeResult, /* isAsync */ false, node)?.type ?? types_1.UnknownType.create();
+            // Does the iterable return a Generator?
+            generatorTypeArgs = (0, typeUtils_1.getGeneratorTypeArgs)(iterableType);
+            return generatorTypeArgs && generatorTypeArgs.length >= 2 ? generatorTypeArgs[2] : types_1.UnknownType.create();
+        });
+        return { type: returnedType };
+    }
+    function getTypeOfSlice(node) {
+        const noneType = getNoneType();
+        let startType = noneType;
+        let endType = noneType;
+        let stepType = noneType;
+        let isIncomplete = false;
+        // Evaluate the expressions to report errors and record symbol
+        // references.
+        if (node.d.startValue) {
+            const startTypeResult = getTypeOfExpression(node.d.startValue);
+            startType = startTypeResult.type;
+            if (startTypeResult.isIncomplete) {
+                isIncomplete = true;
+            }
+        }
+        if (node.d.endValue) {
+            const endTypeResult = getTypeOfExpression(node.d.endValue);
+            endType = endTypeResult.type;
+            if (endTypeResult.isIncomplete) {
+                isIncomplete = true;
+            }
+        }
+        if (node.d.stepValue) {
+            const stepTypeResult = getTypeOfExpression(node.d.stepValue);
+            stepType = stepTypeResult.type;
+            if (stepTypeResult.isIncomplete) {
+                isIncomplete = true;
+            }
+        }
+        const sliceType = getBuiltInObject(node, 'slice');
+        if (!(0, types_1.isClassInstance)(sliceType)) {
+            return { type: sliceType };
+        }
+        return { type: types_1.ClassType.specialize(sliceType, [startType, endType, stepType]), isIncomplete };
+    }
+    function getTypeOfArg(arg, inferenceContext) {
+        if (arg.typeResult) {
+            const type = arg.typeResult.type;
+            return { type: type?.props?.specialForm ?? type, isIncomplete: arg.typeResult.isIncomplete };
+        }
+        if (!arg.valueExpression) {
+            // We shouldn't ever get here, but just in case.
+            return { type: types_1.UnknownType.create() };
+        }
+        // If there was no defined type provided, there should always
+        // be a value expression from which we can retrieve the type.
+        return getTypeOfExpression(arg.valueExpression, /* flags */ undefined, inferenceContext);
+    }
+    function getTypeOfExpressionExpectingType(node, options) {
+        let flags = 128 /* EvalFlags.InstantiableType */ | 8 /* EvalFlags.StrLiteralAsType */;
+        if (options?.allowTypeVarsWithoutScopeId) {
+            flags |= 4096 /* EvalFlags.AllowTypeVarWithoutScopeId */;
+        }
+        if (options?.typeVarGetsCurScope) {
+            flags |= 8192 /* EvalFlags.TypeVarGetsCurScope */;
+        }
+        if (options?.enforceClassTypeVarScope) {
+            flags |= -2147483648 /* EvalFlags.EnforceClassTypeVarScope */;
+        }
+        const fileInfo = nodeInfo.getFileInfo(node);
+        if (((0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(fileInfo) || options?.forwardRefs) && !options?.runtimeTypeExpression) {
+            flags |= 4 /* EvalFlags.ForwardRefs */;
+        }
+        else if (options?.parsesStringLiteral) {
+            flags |= 16777216 /* EvalFlags.ParsesStringLiteral */;
+        }
+        if (!options?.allowFinal) {
+            flags |= 16 /* EvalFlags.NoFinal */;
+        }
+        if (options?.allowRequired) {
+            flags |= 1048576 /* EvalFlags.AllowRequired */ | 256 /* EvalFlags.TypeExpression */;
+        }
+        if (options?.allowReadOnly) {
+            flags |= 2097152 /* EvalFlags.AllowReadOnly */ | 256 /* EvalFlags.TypeExpression */;
+        }
+        if (options?.allowUnpackedTuple) {
+            flags |= 4194304 /* EvalFlags.AllowUnpackedTuple */;
+        }
+        else {
+            flags |= 64 /* EvalFlags.NoTypeVarTuple */;
+        }
+        if (options?.allowUnpackedTypedDict) {
+            flags |= 8388608 /* EvalFlags.AllowUnpackedTypedDict */;
+        }
+        if (!options?.allowParamSpec) {
+            flags |= 32 /* EvalFlags.NoParamSpec */;
+        }
+        if (options?.typeExpression) {
+            flags |= 256 /* EvalFlags.TypeExpression */;
+        }
+        if (options?.convertEllipsisToAny) {
+            flags |= 1 /* EvalFlags.ConvertEllipsisToAny */;
+        }
+        if (options?.allowEllipsis) {
+            flags |= 65536 /* EvalFlags.AllowEllipsis */;
+        }
+        if (options?.noNonTypeSpecialForms) {
+            flags |= 67108864 /* EvalFlags.NoNonTypeSpecialForms */;
+        }
+        if (!options?.allowClassVar) {
+            flags |= 131072 /* EvalFlags.NoClassVar */;
+        }
+        if (options?.varTypeAnnotation) {
+            flags |= 32768 /* EvalFlags.VarTypeAnnotation */;
+        }
+        if (options?.notParsed) {
+            flags |= 524288 /* EvalFlags.NotParsed */;
+        }
+        if (options?.typeFormArg) {
+            flags |= 1073741824 /* EvalFlags.TypeFormArg */;
+        }
+        return getTypeOfExpression(node, flags);
+    }
+    function expandArgTypes(contextFreeArgTypes, expandedArgTypes) {
+        // Find the rightmost already-expanded argument.
+        let indexToExpand = contextFreeArgTypes.length - 1;
+        while (indexToExpand >= 0 && !expandedArgTypes[0][indexToExpand]) {
+            indexToExpand--;
+        }
+        // Move to the next candidate for expansion.
+        indexToExpand++;
+        if (indexToExpand >= contextFreeArgTypes.length) {
+            return undefined;
+        }
+        let expandedTypes;
+        while (indexToExpand < contextFreeArgTypes.length) {
+            // Is this a union type? If so, we can expand it.
+            const argType = contextFreeArgTypes[indexToExpand];
+            expandedTypes = expandArgType(argType);
+            if (expandedTypes) {
+                break;
+            }
+            indexToExpand++;
+        }
+        // We have nothing left to expand.
+        if (!expandedTypes) {
+            return undefined;
+        }
+        // Expand entry indexToExpand.
+        const newExpandedArgTypes = [];
+        expandedArgTypes.forEach((preExpandedTypes) => {
+            expandedTypes.forEach((subtype) => {
+                const expandedTypes = [...preExpandedTypes];
+                expandedTypes[indexToExpand] = subtype;
+                newExpandedArgTypes.push(expandedTypes);
+            });
+        });
+        return newExpandedArgTypes;
+    }
+    function expandArgList(argList) {
+        const expandedArgList = [];
+        for (const arg of argList) {
+            if (arg.argCategory === 1 /* ArgCategory.UnpackedList */) {
+                const argType = getTypeOfArg(arg, /* inferenceContext */ undefined).type;
+                // If this is a tuple with specified element types, use those
+                // specified types rather than using the more generic iterator
+                // type which will be a union of all element types.
+                const combinedArgType = (0, typeUtils_1.combineSameSizedTuples)(makeTopLevelTypeVarsConcrete(argType), context.prefetched?.tupleClass);
+                if ((0, types_1.isClassInstance)(combinedArgType) && (0, typeUtils_1.isTupleClass)(combinedArgType)) {
+                    const tupleTypeArgs = combinedArgType.priv.tupleTypeArgs ?? [];
+                    if (tupleTypeArgs.length !== 1 || !tupleTypeArgs[0].isUnbounded) {
+                        for (const tupleTypeArg of tupleTypeArgs) {
+                            if (tupleTypeArg.isUnbounded) {
+                                expandedArgList.push({
+                                    ...arg,
+                                    argCategory: 1 /* ArgCategory.UnpackedList */,
+                                    valueExpression: undefined,
+                                    typeResult: {
+                                        type: (0, tuples_1.makeTupleObject)(evaluatorInterface, [tupleTypeArg]),
+                                    },
+                                });
+                            }
+                            else {
+                                expandedArgList.push({
+                                    ...arg,
+                                    argCategory: 0 /* ArgCategory.Simple */,
+                                    valueExpression: undefined,
+                                    typeResult: {
+                                        type: tupleTypeArg.type,
+                                    },
+                                });
+                            }
+                        }
+                        continue;
+                    }
+                }
+            }
+            expandedArgList.push(arg);
+        }
+        return expandedArgList;
+    }
+    function expandArgType(type) {
+        const expandedTypes = [];
+        // Expand any top-level type variables with constraints.
+        type = makeTopLevelTypeVarsConcrete(type);
+        (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+            if ((0, types_1.isClassInstance)(subtype)) {
+                // Expand any bool or Enum literals.
+                const expandedLiteralTypes = (0, typeGuards_1.enumerateLiteralsForType)(evaluatorInterface, subtype);
+                if (expandedLiteralTypes && expandedLiteralTypes.length <= maxSingleOverloadArgTypeExpansionCount) {
+                    (0, collectionUtils_1.appendArray)(expandedTypes, expandedLiteralTypes);
+                    return;
+                }
+                // Expand any fixed-size tuples.
+                const expandedTuples = (0, tuples_1.expandTuple)(subtype, maxSingleOverloadArgTypeExpansionCount);
+                if (expandedTuples) {
+                    (0, collectionUtils_1.appendArray)(expandedTypes, expandedTuples);
+                    return;
+                }
+            }
+            expandedTypes.push(subtype);
+        });
+        return expandedTypes.length > 1 ? expandedTypes : undefined;
+    }
+    return {
+        getTypeOfEllipsis,
+        getTypeOfUnpackOperator,
+        getTypeOfString,
+        getDeclaredTypeForExpression,
+        getTypeOfIterator,
+        getTypeOfIterable,
+        getTypeOfIndexedObjectOrClass,
+        getTypeArg,
+        getTypeOfLambdaForCall,
+        getTypeOfTypeForm,
+        getTypeOfAssertType,
+        getTypeOfRevealLocals,
+        getTypeOfSuperCall,
+        evaluateCastCall,
+        getTypeOfConstant,
+        getTypeOfMagicMethodCall,
+        getTypeOfYield,
+        getTypeOfYieldFrom,
+        getTypeOfSlice,
+        getTypeOfArg,
+        getTypeOfExpressionExpectingType,
+        getTypeOfStringList,
+        expandArgTypes,
+        expandArgList,
+    };
+}
+//# sourceMappingURL=expressionEvaluation.js.map