@zzzen/pyright-internal 1.2.0-dev.20220703 → 1.2.0-dev.20220710

package/dist/analyzer/typeEvaluator.js

@@ -915,7 +915,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const argList = [
             {
                 argumentCategory: 0 /* Simple */,
-                type: functionOrClassType,
+                typeResult: { type: functionOrClassType },
             },
         ];
         const returnType = validateCallArguments(node.expression, argList, decoratorTypeResult, 
@@ -1230,7 +1230,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         function addFakeArg() {
             argList.push({
                 argumentCategory: previousCategory,
-                type: types_1.UnknownType.create(),
+                typeResult: { type: types_1.UnknownType.create() },
                 active: true,
             });
         }
@@ -3569,25 +3569,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             {
                                 // Provide "obj" argument.
                                 argumentCategory: 0 /* Simple */,
-                                type: types_1.ClassType.isClassProperty(lookupClass)
-                                    ? baseTypeClass
-                                    : isAccessedThroughObject
-                                        ? bindToType || types_1.ClassType.cloneAsInstance(baseTypeClass)
-                                        : types_1.NoneType.createInstance(),
+                                typeResult: {
+                                    type: types_1.ClassType.isClassProperty(lookupClass)
+                                        ? baseTypeClass
+                                        : isAccessedThroughObject
+                                            ? bindToType || types_1.ClassType.cloneAsInstance(baseTypeClass)
+                                            : types_1.NoneType.createInstance(),
+                                },
                             },
                         ];
                         if (usage.method === 'get') {
                             // Provide "objtype" argument.
                             argList.push({
                                 argumentCategory: 0 /* Simple */,
-                                type: baseTypeClass,
+                                typeResult: { type: baseTypeClass },
                             });
                         }
                         else if (usage.method === 'set') {
                             // Provide "value" argument.
                             argList.push({
                                 argumentCategory: 0 /* Simple */,
-                                type: (_a = usage.setType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(),
+                                typeResult: { type: (_a = usage.setType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create() },
                             });
                         }
                         if (types_1.ClassType.isPropertyClass(lookupClass) &&
@@ -3821,55 +3823,57 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // Applies the __getattr__, __setattr__ or __delattr__ method if present.
     function applyAttributeAccessOverride(classType, errorNode, usage, memberName) {
-        var _a, _b, _c, _d;
-        if (usage.method === 'get') {
+        var _a, _b, _c;
+        const getAttributeAccessMember = (name) => {
+            var _a;
             // See if the class has a "__getattribute__" or "__getattr__" method.
             // If so, arbitrary members are supported.
-            let getAttrType = (_a = getTypeOfClassMember(errorNode, classType, '__getattribute__', { method: 'get' }, 
+            return (_a = getTypeOfClassMember(errorNode, classType, name, { method: 'get' }, 
             /* diag */ undefined, 4 /* SkipObjectBaseClass */ | 64 /* SkipAttributeAccessOverride */)) === null || _a === void 0 ? void 0 : _a.type;
-            if (!getAttrType) {
-                getAttrType = (_b = getTypeOfClassMember(errorNode, classType, '__getattr__', { method: 'get' }, 
-                /* diag */ undefined, 4 /* SkipObjectBaseClass */ | 64 /* SkipAttributeAccessOverride */)) === null || _b === void 0 ? void 0 : _b.type;
-            }
-            // If it's an overload, it might be based on the member name. Create
-            // a literal str type based on the member name and find the best overload.
-            if (getAttrType && (0, types_1.isOverloadedFunction)(getAttrType)) {
-                let nameLiteralType = types_1.AnyType.create();
-                if (strClassType && (0, types_1.isInstantiableClass)(strClassType)) {
-                    nameLiteralType = types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneAsInstance(strClassType), memberName);
-                }
-                getAttrType = getBestOverloadForArguments(errorNode, getAttrType, [
-                    {
-                        argumentCategory: 0 /* Simple */,
-                        type: types_1.AnyType.create(),
-                    },
-                    {
-                        argumentCategory: 0 /* Simple */,
-                        type: nameLiteralType,
-                    },
-                ]);
-            }
-            if (getAttrType && (0, types_1.isFunction)(getAttrType)) {
-                return getFunctionEffectiveReturnType(getAttrType);
-            }
+        };
+        let accessMemberType;
+        if (usage.method === 'get') {
+            accessMemberType = (_a = getAttributeAccessMember('__getattribute__')) !== null && _a !== void 0 ? _a : getAttributeAccessMember('__getattr__');
         }
         else if (usage.method === 'set') {
-            const setAttrType = (_c = getTypeOfClassMember(errorNode, classType, '__setattr__', { method: 'get' }, 
-            /* diag */ undefined, 4 /* SkipObjectBaseClass */ | 64 /* SkipAttributeAccessOverride */)) === null || _c === void 0 ? void 0 : _c.type;
-            if (setAttrType) {
-                // The type doesn't matter for a set usage. We just need
-                // to return a defined type.
-                return types_1.AnyType.create();
-            }
+            accessMemberType = getAttributeAccessMember('__setattr__');
         }
         else {
             (0, debug_1.assert)(usage.method === 'del');
-            const delAttrType = (_d = getTypeOfClassMember(errorNode, classType, '__detattr__', { method: 'get' }, 
-            /* diag */ undefined, 4 /* SkipObjectBaseClass */ | 64 /* SkipAttributeAccessOverride */)) === null || _d === void 0 ? void 0 : _d.type;
-            if (delAttrType) {
-                // The type doesn't matter for a delete usage. We just need
-                // to return a defined type.
-                return types_1.AnyType.create();
+            accessMemberType = getAttributeAccessMember('__delattr__');
+        }
+        if (accessMemberType) {
+            let nameLiteralType = types_1.AnyType.create();
+            if (strClassType && (0, types_1.isInstantiableClass)(strClassType)) {
+                nameLiteralType = types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneAsInstance(strClassType), memberName);
+            }
+            const argList = [
+                {
+                    // Provide "self" argument.
+                    argumentCategory: 0 /* Simple */,
+                    typeResult: { type: types_1.ClassType.cloneAsInstance(classType) },
+                },
+                {
+                    // Provide "name" argument.
+                    argumentCategory: 0 /* Simple */,
+                    typeResult: { type: nameLiteralType },
+                },
+            ];
+            if (usage.method === 'set') {
+                argList.push({
+                    // Provide "value" argument.
+                    argumentCategory: 0 /* Simple */,
+                    typeResult: { type: (_b = usage.setType) !== null && _b !== void 0 ? _b : types_1.UnknownType.create() },
+                });
+            }
+            if ((0, types_1.isFunction)(accessMemberType) || (0, types_1.isOverloadedFunction)(accessMemberType)) {
+                const boundMethodType = bindFunctionToClassOrObject(classType, accessMemberType, classType, errorNode);
+                if (boundMethodType && ((0, types_1.isFunction)(boundMethodType) || (0, types_1.isOverloadedFunction)(boundMethodType))) {
+                    const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(boundMethodType));
+                    const callResult = validateCallArguments(errorNode, argList, { type: boundMethodType }, typeVarContext, 
+                    /* skipUnknownArgCheck */ true);
+                    return (_c = callResult.returnType) !== null && _c !== void 0 ? _c : types_1.UnknownType.create();
+                }
             }
         }
         return undefined;
@@ -4408,9 +4412,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const keywordArgs = node.items.filter((item) => item.argumentCategory === 0 /* Simple */ && !!item.name);
         const unpackedDictArgs = node.items.filter((item) => item.argumentCategory === 2 /* UnpackedDictionary */);
         let positionalIndexType;
+        let isPositionalIndexTypeIncomplete = false;
         if (positionalArgs.length === 1 && unpackedListArgs.length === 0 && !node.trailingComma) {
             // Handle the common case where there is a single positional argument.
-            positionalIndexType = getTypeOfExpression(positionalArgs[0].valueExpression).type;
+            const typeResult = getTypeOfExpression(positionalArgs[0].valueExpression);
+            positionalIndexType = typeResult.type;
+            if (typeResult.isIncomplete) {
+                isPositionalIndexTypeIncomplete = true;
+            }
         }
         else if (positionalArgs.length === 0 && unpackedListArgs.length === 0) {
             // Handle the case where there are no positionals provided but there are keywords.
@@ -4423,10 +4432,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Package up all of the positionals into a tuple.
             const tupleEntries = [];
             positionalArgs.forEach((arg) => {
-                tupleEntries.push(getTypeOfExpression(arg.valueExpression).type);
+                const typeResult = getTypeOfExpression(arg.valueExpression);
+                tupleEntries.push(typeResult.type);
+                if (typeResult.isIncomplete) {
+                    isPositionalIndexTypeIncomplete = true;
+                }
             });
             unpackedListArgs.forEach((arg) => {
-                const exprType = getTypeOfExpression(arg.valueExpression).type;
+                const typeResult = getTypeOfExpression(arg.valueExpression);
+                const exprType = typeResult.type;
+                if (typeResult.isIncomplete) {
+                    isPositionalIndexTypeIncomplete = true;
+                }
                 const iterableType = getTypeOfIterator(exprType, /* isAsync */ false, arg) || types_1.UnknownType.create();
                 tupleEntries.push(iterableType);
             });
@@ -4435,7 +4452,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let argList = [
             {
                 argumentCategory: 0 /* Simple */,
-                type: positionalIndexType,
+                typeResult: { type: positionalIndexType, isIncomplete: isPositionalIndexTypeIncomplete },
             },
         ];
         if (usage.method === 'set') {
@@ -4447,7 +4464,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             argList.push({
                 argumentCategory: 0 /* Simple */,
-                type: setType,
+                typeResult: { type: setType, isIncomplete: isPositionalIndexTypeIncomplete },
             });
         }
         keywordArgs.forEach((arg) => {
@@ -4469,29 +4486,31 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Speculatively attempt the call. We may need to replace the index
         // type with 'int', and we don't want to emit errors before we know
         // which type to use.
-        useSpeculativeMode(node, () => {
-            callResult = validateCallArguments(node, argList, { type: itemMethodType });
-            if (callResult.argumentErrors) {
-                // If the object supports "__index__" magic method, convert
-                // the index it to an int and try again.
-                if ((0, types_1.isClassInstance)(positionalIndexType) && keywordArgs.length === 0 && unpackedDictArgs.length === 0) {
-                    const altArgList = [...argList];
-                    altArgList[0] = { ...altArgList[0] };
-                    const indexMethod = getTypeOfObjectMember(node, positionalIndexType, '__index__');
-                    if (indexMethod) {
-                        const intType = getBuiltInObject(node, 'int');
-                        if ((0, types_1.isClassInstance)(intType)) {
-                            altArgList[0].type = intType;
+        if (keywordArgs.length === 0 && unpackedDictArgs.length === 0 && positionalArgs.length === 1) {
+            useSpeculativeMode(node, () => {
+                callResult = validateCallArguments(node, argList, { type: itemMethodType });
+                if (callResult.argumentErrors) {
+                    // If the object supports "__index__" magic method, convert
+                    // the index to an int and try again.
+                    if ((0, types_1.isClassInstance)(positionalIndexType)) {
+                        const altArgList = [...argList];
+                        altArgList[0] = { ...altArgList[0] };
+                        const indexMethod = getTypeOfObjectMember(node, positionalIndexType, '__index__');
+                        if (indexMethod) {
+                            const intType = getBuiltInObject(node, 'int');
+                            if ((0, types_1.isClassInstance)(intType)) {
+                                altArgList[0].typeResult = { type: intType };
+                            }
+                        }
+                        callResult = validateCallArguments(node, altArgList, { type: itemMethodType });
+                        // We were successful, so replace the arg list.
+                        if (!callResult.argumentErrors) {
+                            argList = altArgList;
                         }
-                    }
-                    callResult = validateCallArguments(node, altArgList, { type: itemMethodType });
-                    // We were successful, so replace the arg list.
-                    if (!callResult.argumentErrors) {
-                        argList = altArgList;
                     }
                 }
-            }
-        });
+            });
+        }
         callResult = validateCallArguments(node, argList, { type: itemMethodType });
         return {
             node,
@@ -5301,8 +5320,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // the expectedType. We'll use this to determine whether we need to do
                     // union expansion.
                     contextFreeArgTypes = argList.map((arg) => {
-                        if (arg.type) {
-                            return arg.type;
+                        if (arg.typeResult) {
+                            return arg.typeResult.type;
                         }
                         if (arg.valueExpression) {
                             const valueExpressionNode = arg.valueExpression;
@@ -6204,7 +6223,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const funcArg = listElementType
                     ? {
                         argumentCategory: 0 /* Simple */,
-                        type: listElementType,
+                        typeResult: { type: listElementType, isIncomplete: argTypeResult.isIncomplete },
                     }
                     : undefined;
                 if (funcArg && argTypeResult.isIncomplete) {
@@ -6369,7 +6388,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                         argument: {
                                             argumentCategory: 0 /* Simple */,
-                                            type: entry.valueType,
+                                            typeResult: { type: entry.valueType },
                                         },
                                         errorNode: argList[argIndex].valueExpression || errorNode,
                                         paramName: name,
@@ -6384,7 +6403,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                     argument: {
                                         argumentCategory: 0 /* Simple */,
-                                        type: entry.valueType,
+                                        typeResult: { type: entry.valueType },
                                     },
                                     errorNode: argList[argIndex].valueExpression || errorNode,
                                     paramName: name,
@@ -6574,7 +6593,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                             argument: {
                                 argumentCategory: 0 /* Simple */,
-                                type: unpackedDictionaryArgType,
+                                typeResult: { type: unpackedDictionaryArgType },
                             },
                             errorNode: (_b = (_a = argList.find((arg) => arg.argumentCategory === 2 /* UnpackedDictionary */)) === null || _a === void 0 ? void 0 : _a.valueExpression) !== null && _b !== void 0 ? _b : errorNode,
                             paramName: param.name,
@@ -6621,7 +6640,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     requiresTypeVarMatching: true,
                                     argument: {
                                         argumentCategory: 0 /* Simple */,
-                                        type: defaultArgType,
+                                        typeResult: { type: defaultArgType },
                                     },
                                     errorNode: errorNode,
                                     paramName: param.name,
@@ -6675,7 +6694,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             paramCategory: 1 /* VarArgList */,
                             paramType,
                             requiresTypeVarMatching: true,
-                            argument: { argumentCategory: 0 /* Simple */, type: specializedTuple },
+                            argument: {
+                                argumentCategory: 0 /* Simple */,
+                                typeResult: { type: specializedTuple },
+                            },
                             errorNode,
                             paramName: paramDetails.params[paramDetails.argsIndex].param.name,
                             isParamNameSynthesized: paramDetails.params[paramDetails.argsIndex].param.isNameSynthesized,
@@ -7177,7 +7199,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (argParam.argType) {
                 argType = argParam.argType;
             }
-            else if (argParam.expectingType && !argParam.argument.type && argParam.argument.valueExpression) {
+            else if (argParam.expectingType && !argParam.argument.typeResult && argParam.argument.valueExpression) {
                 const argTypeResult = getTypeOfExpression(argParam.argument.valueExpression, 8 /* EvaluateStringLiteralAsType */ |
                     32 /* ParamSpecDisallowed */ |
                     128 /* TypeVarTupleDisallowed */);
@@ -7356,7 +7378,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { isCompatible, argType, isTypeIncomplete, condition };
     }
     function createTypeVarType(errorNode, argList) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         let typeVarName = '';
         let firstConstraintArg;
         if (argList.length === 0) {
@@ -7385,7 +7407,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         addError(localize_1.Localizer.Diagnostic.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
                     }
                     else {
-                        const argType = (_a = argList[i].type) !== null && _a !== void 0 ? _a : getTypeOfExpressionExpectingType(argList[i].valueExpression, 
+                        const argType = (_b = (_a = argList[i].typeResult) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : getTypeOfExpressionExpectingType(argList[i].valueExpression, 
                         /* allowFinal */ undefined, 
                         /* allowRequired */ undefined).type;
                         if ((0, typeUtils_1.requiresSpecialization)(argType, /* ignorePseudoGeneric */ true)) {
@@ -7396,26 +7418,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else if (paramName === 'covariant') {
                     if (argList[i].valueExpression && getBooleanValue(argList[i].valueExpression)) {
-                        if (typeVar.details.declaredVariance === 3 /* Contravariant */) {
+                        if (typeVar.details.declaredVariance === 4 /* Contravariant */) {
                             addError(localize_1.Localizer.Diagnostic.typeVarVariance(), argList[i].valueExpression);
                         }
                         else {
-                            typeVar.details.declaredVariance = 2 /* Covariant */;
+                            typeVar.details.declaredVariance = 3 /* Covariant */;
                         }
                     }
                 }
                 else if (paramName === 'contravariant') {
                     if (argList[i].valueExpression && getBooleanValue(argList[i].valueExpression)) {
-                        if (typeVar.details.declaredVariance === 2 /* Covariant */) {
+                        if (typeVar.details.declaredVariance === 3 /* Covariant */) {
                             addError(localize_1.Localizer.Diagnostic.typeVarVariance(), argList[i].valueExpression);
                         }
                         else {
-                            typeVar.details.declaredVariance = 3 /* Contravariant */;
+                            typeVar.details.declaredVariance = 4 /* Contravariant */;
                         }
                     }
                 }
                 else {
-                    addError(localize_1.Localizer.Diagnostic.typeVarUnknownParam().format({ name: paramName }), ((_b = argList[i].node) === null || _b === void 0 ? void 0 : _b.name) || argList[i].valueExpression || errorNode);
+                    addError(localize_1.Localizer.Diagnostic.typeVarUnknownParam().format({ name: paramName }), ((_c = argList[i].node) === null || _c === void 0 ? void 0 : _c.name) || argList[i].valueExpression || errorNode);
                 }
                 paramNameMap.set(paramName, paramName);
             }
@@ -7424,7 +7446,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     addError(localize_1.Localizer.Diagnostic.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
                 }
                 else {
-                    const argType = (_c = argList[i].type) !== null && _c !== void 0 ? _c : getTypeOfExpressionExpectingType(argList[i].valueExpression, 
+                    const argType = (_e = (_d = argList[i].typeResult) === null || _d === void 0 ? void 0 : _d.type) !== null && _e !== void 0 ? _e : getTypeOfExpressionExpectingType(argList[i].valueExpression, 
                     /* allowFinal */ undefined, 
                     /* allowRequired */ undefined).type;
                     if ((0, typeUtils_1.requiresSpecialization)(argType, /* ignorePseudoGeneric */ true)) {
@@ -7919,7 +7941,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // incomplete because we may be evaluating types within a loop,
         // so the literal values may change each time.
         const isLiteralMathAllowed = !ParseTreeUtils.isWithinLoop(node);
-        let type = validateBinaryOperation(node.operator, leftType, rightType, node, expectedType, diag, isLiteralMathAllowed);
+        let type = validateBinaryOperation(node.operator, { type: leftType, isIncomplete: leftTypeResult.isIncomplete }, { type: rightType, isIncomplete: rightTypeResult.isIncomplete }, node, expectedType, diag, isLiteralMathAllowed);
         if (!diag.isEmpty() || !type) {
             if (!isIncomplete) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -8005,14 +8027,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return (0, typeUtils_1.preserveUnknown)(leftSubtypeUnexpanded, rightSubtypeUnexpanded);
                     }
                     const magicMethodName = operatorMap[node.operator][0];
-                    let returnType = getTypeOfMagicMethodReturn(leftSubtypeUnexpanded, [rightSubtypeUnexpanded], magicMethodName, node, expectedType);
+                    let returnType = getTypeOfMagicMethodReturn(leftSubtypeUnexpanded, [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, node, expectedType);
                     if (!returnType && leftSubtypeUnexpanded !== leftSubtypeExpanded) {
                         // Try with the expanded left type.
-                        returnType = getTypeOfMagicMethodReturn(leftSubtypeExpanded, [rightSubtypeUnexpanded], magicMethodName, node, expectedType);
+                        returnType = getTypeOfMagicMethodReturn(leftSubtypeExpanded, [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, node, expectedType);
                     }
                     if (!returnType && rightSubtypeUnexpanded !== rightSubtypeExpanded) {
                         // Try with the expanded left and right type.
-                        returnType = getTypeOfMagicMethodReturn(leftSubtypeExpanded, [rightSubtypeExpanded], magicMethodName, node, expectedType);
+                        returnType = getTypeOfMagicMethodReturn(leftSubtypeExpanded, [{ type: rightSubtypeExpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, node, expectedType);
                     }
                     if (!returnType) {
                         // If the LHS class didn't support the magic method for augmented
@@ -8025,7 +8047,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             !rightTypeResult.isIncomplete &&
                             (0, typeUtils_1.getUnionSubtypeCount)(leftType) * (0, typeUtils_1.getUnionSubtypeCount)(rightType) <
                                 maxLiteralMathSubtypeCount;
-                        returnType = validateBinaryOperation(binaryOperator, leftSubtypeUnexpanded, rightSubtypeUnexpanded, node, expectedType, diag, isLiteralMathAllowed);
+                        returnType = validateBinaryOperation(binaryOperator, { type: leftSubtypeUnexpanded, isIncomplete: leftTypeResult.isIncomplete }, { type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }, node, expectedType, diag, isLiteralMathAllowed);
                     }
                     return returnType;
                 });
@@ -8048,7 +8070,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         assignTypeToExpression(node.destExpression, typeResult.type, !!typeResult.isIncomplete, node.rightExpression);
         return typeResult;
     }
-    function validateBinaryOperation(operator, leftType, rightType, errorNode, expectedType, diag, isLiteralMathAllowed) {
+    function validateBinaryOperation(operator, leftTypeResult, rightTypeResult, errorNode, expectedType, diag, isLiteralMathAllowed) {
+        const leftType = leftTypeResult.type;
+        const rightType = rightTypeResult.type;
         let type;
         let concreteLeftType = makeTopLevelTypeVarsConcrete(leftType);
         if (booleanOperatorMap[operator] !== undefined) {
@@ -8098,7 +8122,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if ((0, types_1.isAnyOrUnknown)(leftSubtype) || (0, types_1.isAnyOrUnknown)(rightSubtypeUnexpanded)) {
                             return (0, typeUtils_1.preserveUnknown)(leftSubtype, rightSubtypeExpanded);
                         }
-                        let returnType = getTypeOfMagicMethodReturn(rightSubtypeExpanded, [leftSubtype], '__contains__', errorNode, 
+                        let returnType = getTypeOfMagicMethodReturn(rightSubtypeExpanded, [{ type: leftSubtype, isIncomplete: leftTypeResult.isIncomplete }], '__contains__', errorNode, 
                         /* expectedType */ undefined);
                         if (!returnType) {
                             // If __contains__ was not supported, fall back
@@ -8255,26 +8279,31 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             ]));
                         }
                         const magicMethodName = binaryOperatorMap[operator][0];
-                        let resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeUnexpanded), [rightSubtypeUnexpanded], magicMethodName, errorNode, expectedType);
+                        let resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeUnexpanded), [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, errorNode, expectedType);
                         if (!resultType && leftSubtypeUnexpanded !== leftSubtypeExpanded) {
                             // Try the expanded left type.
-                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeExpanded), [rightSubtypeUnexpanded], magicMethodName, errorNode, expectedType);
+                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeExpanded), [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, errorNode, expectedType);
                         }
                         if (!resultType && rightSubtypeUnexpanded !== rightSubtypeExpanded) {
                             // Try the expanded left and right type.
-                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeExpanded), [rightSubtypeExpanded], magicMethodName, errorNode, expectedType);
+                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeExpanded), [{ type: rightSubtypeExpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, errorNode, expectedType);
                         }
                         if (!resultType) {
                             // Try the alternate form (swapping right and left).
                             const altMagicMethodName = binaryOperatorMap[operator][1];
-                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeUnexpanded), [leftSubtypeUnexpanded], altMagicMethodName, errorNode, expectedType);
+                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeUnexpanded), [{ type: leftSubtypeUnexpanded, isIncomplete: leftTypeResult.isIncomplete }], altMagicMethodName, errorNode, expectedType);
                             if (!resultType && rightSubtypeUnexpanded !== rightSubtypeExpanded) {
                                 // Try the expanded right type.
-                                resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeExpanded), [leftSubtypeUnexpanded], altMagicMethodName, errorNode, expectedType);
+                                resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeExpanded), [
+                                    {
+                                        type: leftSubtypeUnexpanded,
+                                        isIncomplete: leftTypeResult.isIncomplete,
+                                    },
+                                ], altMagicMethodName, errorNode, expectedType);
                             }
                             if (!resultType && leftSubtypeUnexpanded !== leftSubtypeExpanded) {
                                 // Try the expanded right and left type.
-                                resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeExpanded), [leftSubtypeExpanded], altMagicMethodName, errorNode, expectedType);
+                                resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeExpanded), [{ type: leftSubtypeExpanded, isIncomplete: leftTypeResult.isIncomplete }], altMagicMethodName, errorNode, expectedType);
                             }
                         }
                         if (!resultType) {
@@ -8322,7 +8351,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const functionArgs = args.map((arg) => {
                     return {
                         argumentCategory: 0 /* Simple */,
-                        type: arg,
+                        typeResult: arg,
                     };
                 });
                 let callResult;
@@ -9118,15 +9147,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { type, node, isIncomplete };
     }
     function getTypeOfSlice(node) {
-        // Evaluate the expressions to report errors and record symbol references.
-        if (node.startValue) {
-            getTypeOfExpression(node.startValue);
-        }
-        if (node.endValue) {
-            getTypeOfExpression(node.endValue);
-        }
-        if (node.stepValue) {
-            getTypeOfExpression(node.stepValue);
+        // Evaluate the expressions to report errors and record symbol
+        // references. We can skip this if we're executing speculatively.
+        if (!speculativeTypeTracker.isSpeculative(node)) {
+            if (node.startValue) {
+                getTypeOfExpression(node.startValue);
+            }
+            if (node.endValue) {
+                getTypeOfExpression(node.endValue);
+            }
+            if (node.stepValue) {
+                getTypeOfExpression(node.stepValue);
+            }
         }
         return { type: getBuiltInObject(node, 'slice'), node };
     }
@@ -10622,6 +10654,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         const effectiveMetaclass = computeEffectiveMetaclass(classType, node.name);
+        // Clear the "partially constructed" flag.
+        classType.details.flags &= ~131072 /* PartiallyEvaluated */;
         // Now determine the decorated type of the class.
         let decoratedType = classType;
         let foundUnknown = false;
@@ -10658,8 +10692,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             (0, dataClasses_1.applyDataClassDefaultBehaviors)(classType, dataClassBehaviors);
             (0, dataClasses_1.applyDataClassClassBehaviorOverrides)(evaluatorInterface, classType, initSubclassArgs);
         }
-        // Clear the "partially constructed" flag.
-        classType.details.flags &= ~131072 /* PartiallyEvaluated */;
         // Run any class hooks that depend on this class.
         runClassTypeHooks(classType);
         // Synthesize TypedDict methods.
@@ -10742,6 +10774,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!objectType || !(0, types_1.isClassInstance)(objectType)) {
             return;
         }
+        // Presumptively mark the variance inference as complete. This
+        // prevents potential recursion.
+        classType.details.requiresVarianceInference = false;
+        // Presumptively mark the computed variance to "in progress". We'll
+        // replace this below once the variance has been inferred.
+        classType.details.typeParameters.forEach((param) => {
+            if (param.details.declaredVariance === 0 /* Auto */) {
+                param.computedVariance = 1 /* Unknown */;
+            }
+        });
         // Replace all of the type parameters with invariant TypeVars.
         const updatedTypeParams = classType.details.typeParameters.map((typeParam) => types_1.TypeVarType.cloneAsInvariant(typeParam));
         const updatedClassType = types_1.ClassType.cloneWithNewTypeParameters(classType, updatedTypeParams);
@@ -10775,15 +10817,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const isDestSubtypeOfSrc = assignClassToSelf(srcType, destType);
             let inferredVariance;
             if (isDestSubtypeOfSrc) {
-                inferredVariance = 2 /* Covariant */;
+                inferredVariance = 3 /* Covariant */;
             }
             else {
                 const isSrcSubtypeOfDest = assignClassToSelf(destType, srcType);
                 if (isSrcSubtypeOfDest) {
-                    inferredVariance = 3 /* Contravariant */;
+                    inferredVariance = 4 /* Contravariant */;
                 }
                 else {
-                    inferredVariance = 1 /* Invariant */;
+                    inferredVariance = 2 /* Invariant */;
                 }
             }
             // We assume here that we don't need to clone the type var object
@@ -10791,8 +10833,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // class scope.
             classType.details.typeParameters[paramIndex].computedVariance = inferredVariance;
         });
-        // Note that variance inference is complete.
-        classType.details.requiresVarianceInference = false;
     }
     function evaluateTypeParameterList(node) {
         const paramTypes = [];
@@ -13061,8 +13101,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return specializedClass;
     }
     function getTypeOfArgument(arg) {
-        if (arg.type) {
-            return { type: arg.type };
+        if (arg.typeResult) {
+            return { type: arg.typeResult.type, isIncomplete: arg.typeResult.isIncomplete };
         }
         if (!arg.valueExpression) {
             // We shouldn't ever get here, but just in case.
@@ -13077,8 +13117,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // and therefore follows the normal rules of types (e.g. they
     // can be forward-declared in stubs, etc.).
     function getTypeOfArgumentExpectingType(arg) {
-        if (arg.type) {
-            return { type: arg.type };
+        if (arg.typeResult) {
+            return { type: arg.typeResult.type, isIncomplete: arg.typeResult.isIncomplete };
         }
         // If there was no defined type provided, there should always
         // be a value expression from which we can retrieve the type.
@@ -14702,7 +14742,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const destTypeArg = destArgIndex >= 0 ? destTypeArgs[destArgIndex] : types_1.UnknownType.create();
                 const destTypeParam = destArgIndex < destTypeParams.length ? destTypeParams[destArgIndex] : undefined;
                 const assignmentDiag = new diagnostic_1.DiagnosticAddendum();
-                if (!destTypeParam || types_1.TypeVarType.getVariance(destTypeParam) === 2 /* Covariant */) {
+                if (!destTypeParam || types_1.TypeVarType.getVariance(destTypeParam) === 3 /* Covariant */) {
                     if (!assignType(destTypeArg, srcTypeArg, assignmentDiag, destTypeVarContext, srcTypeVarContext, flags | 128 /* RetainLiteralsForTypeVar */, recursionCount)) {
                         if (diag) {
                             if (destTypeParam) {
@@ -14719,7 +14759,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return false;
                     }
                 }
-                else if (types_1.TypeVarType.getVariance(destTypeParam) === 3 /* Contravariant */) {
+                else if (types_1.TypeVarType.getVariance(destTypeParam) === 4 /* Contravariant */) {
                     if (!assignType(srcTypeArg, destTypeArg, assignmentDiag, srcTypeVarContext, destTypeVarContext, (flags ^ 2 /* ReverseTypeVarMatching */) | 128 /* RetainLiteralsForTypeVar */, recursionCount)) {
                         if (diag) {
                             const childDiag = diag.createAddendum();
@@ -15402,6 +15442,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // matches for types like `tuple[Any]` and `tuple[int]` from being considered
     // proper subtypes of each other.
     function isProperSubtype(destType, srcType, recursionCount) {
+        // Shortcut the check if either type is Any or Unknown.
+        if ((0, types_1.isAnyOrUnknown)(destType) || (0, types_1.isAnyOrUnknown)(srcType)) {
+            return true;
+        }
+        // Shortcut the check if either type is a class whose hierarchy contains an unknown type.
+        if ((0, types_1.isClass)(destType) && destType.details.mro.some((mro) => (0, types_1.isAnyOrUnknown)(mro))) {
+            return true;
+        }
+        if ((0, types_1.isClass)(srcType) && srcType.details.mro.some((mro) => (0, types_1.isAnyOrUnknown)(mro))) {
+            return true;
+        }
         return (assignType(destType, srcType, 
         /* diag */ undefined, 
         /* destTypeVarContext */ undefined,