@zzzen/pyright-internal 1.2.0-dev.20230101 → 1.2.0-dev.20230108

package/dist/analyzer/typeEvaluator.js

@@ -282,16 +282,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         effectiveTypeCache = new Map();
         expectedTypeCache = new Map();
     }
-    function isTypeCached(node) {
-        let cachedType;
-        if (returnTypeInferenceTypeCache && isNodeInReturnTypeInferenceContext(node)) {
-            cachedType = returnTypeInferenceTypeCache.get(node.id);
-        }
-        else {
-            cachedType = typeCache.get(node.id);
-        }
-        return cachedType !== undefined && !cachedType.isIncomplete;
-    }
     function readTypeCacheEntry(node) {
         // Should we use a temporary cache associated with a contextual
         // analysis of a function, contextualized based on call-site argument types?
@@ -302,10 +292,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return typeCache.get(node.id);
         }
     }
+    function isTypeCached(node) {
+        const cachedEntry = readTypeCacheEntry(node);
+        return cachedEntry !== undefined && !cachedEntry.typeResult.isIncomplete;
+    }
     function readTypeCache(node, flags) {
         var _a, _b;
         const cacheEntry = readTypeCacheEntry(node);
-        if (!cacheEntry || cacheEntry.isIncomplete) {
+        if (!cacheEntry || cacheEntry.typeResult.isIncomplete) {
             return undefined;
         }
         if (evaluatorOptions.verifyTypeCacheEvaluatorFlags || verifyTypeCacheEvaluatorFlags) {
@@ -327,22 +321,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        return cacheEntry.type;
+        return cacheEntry.typeResult.type;
     }
-    function writeTypeCache(node, type, flags, isIncomplete, expectedType, allowSpeculativeCaching = false) {
+    function writeTypeCache(node, typeResult, flags, expectedType, allowSpeculativeCaching = false) {
         // Should we use a temporary cache associated with a contextual
         // analysis of a function, contextualized based on call-site argument types?
         const typeCacheToUse = returnTypeInferenceTypeCache && isNodeInReturnTypeInferenceContext(node)
             ? returnTypeInferenceTypeCache
             : typeCache;
-        typeCacheToUse.set(node.id, { type, isIncomplete, flags });
+        typeCacheToUse.set(node.id, { typeResult, flags });
         // If the entry is located within a part of the parse tree that is currently being
         // "speculatively" evaluated, track it so we delete the cached entry when we leave
         // this speculative context.
         if (speculativeTypeTracker.isSpeculative(node)) {
             speculativeTypeTracker.trackEntry(typeCacheToUse, node.id);
-            if (allowSpeculativeCaching) {
-                speculativeTypeTracker.addSpeculativeType(node, { type, isIncomplete }, expectedType);
+            if (allowSpeculativeCaching && !typeResult.isIncomplete) {
+                speculativeTypeTracker.addSpeculativeType(node, typeResult, expectedType);
             }
         }
     }
@@ -353,7 +347,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         typeCacheToUse.delete(node.id);
     }
     function setTypeForNode(node, type = types_1.UnknownType.create(), flags = 0 /* None */) {
-        writeTypeCache(node, type, flags, /* isIncomplete */ false);
+        writeTypeCache(node, { type }, flags);
     }
     function setAsymmetricDescriptorAssignment(node) {
         if (speculativeTypeTracker.isSpeculative(/* node */ undefined)) {
@@ -435,6 +429,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             evaluateTypesForExpressionInContext(node);
         })) === null || _a === void 0 ? void 0 : _a.type;
     }
+    function getTypeResult(node) {
+        return evaluateTypeForSubnode(node, () => {
+            evaluateTypesForExpressionInContext(node);
+        });
+    }
     // Reads the type of the node from the cache.
     function getCachedType(node) {
         return readTypeCache(node, 0 /* None */);
@@ -496,12 +495,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfExpression(node, flags = 0 /* None */, expectedType) {
         var _a;
         // Is this type already cached?
-        const cachedType = readTypeCache(node, flags);
-        if (cachedType) {
+        const cacheEntry = readTypeCacheEntry(node);
+        if (cacheEntry && !cacheEntry.typeResult.isIncomplete) {
             if (printExpressionTypes) {
-                console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Cached ${printType(cachedType)}`);
+                console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Cached ${printType(cacheEntry.typeResult.type)} ${cacheEntry.typeResult.typeErrors ? ' Errors' : ''}`);
             }
-            return { type: cachedType };
+            return cacheEntry.typeResult;
         }
         else {
             // Is it cached in the speculative type cache?
@@ -510,7 +509,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (printExpressionTypes) {
                     console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Speculative ${printType(cachedTypeResult.type)}`);
                 }
-                return { type: cachedTypeResult.type, isIncomplete: cachedTypeResult.isIncomplete };
+                return cachedTypeResult;
             }
         }
         if (printExpressionTypes) {
@@ -695,8 +694,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 typeResult.type.details.illegalRecursionDetected = true;
             }
         }
-        writeTypeCache(node, typeResult.type, flags, !!typeResult.isIncomplete, expectedType, 
-        /* allowSpeculativeCaching */ true);
+        writeTypeCache(node, typeResult, flags, expectedType, /* allowSpeculativeCaching */ true);
         if (expectedType && !(0, types_1.isAnyOrUnknown)(expectedType) && !(0, types_1.isNever)(expectedType)) {
             expectedTypeCache.set(node.id, expectedType);
             if (!typeResult.isIncomplete && !typeResult.expectedTypeDiagAddendum) {
@@ -2087,7 +2085,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!isTypeIncomplete) {
             reportPossibleUnknownAssignment(fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, nameNode, destType, nameNode, ignoreEmptyContainers);
         }
-        writeTypeCache(nameNode, destType, 0 /* None */, isTypeIncomplete);
+        writeTypeCache(nameNode, { type: destType, isIncomplete: isTypeIncomplete }, 0 /* None */);
     }
     function assignTypeToMemberAccessNode(target, type, isTypeIncomplete, srcExpr, expectedTypeDiagAddendum) {
         const baseTypeResult = getTypeOfExpression(target.leftExpression, 2 /* DoNotSpecialize */);
@@ -2131,8 +2129,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (setTypeResult.isAsymmetricDescriptor) {
             setAsymmetricDescriptorAssignment(target);
         }
-        writeTypeCache(target.memberName, type, 0 /* None */, isTypeIncomplete);
-        writeTypeCache(target, type, 0 /* None */, isTypeIncomplete);
+        writeTypeCache(target.memberName, { type, isIncomplete: isTypeIncomplete }, 0 /* None */);
+        writeTypeCache(target, { type, isIncomplete: isTypeIncomplete }, 0 /* None */);
     }
     function assignTypeToMemberVariable(node, srcType, isTypeIncomplete, isInstanceMember, srcExprNode) {
         const memberName = node.memberName.value;
@@ -2307,7 +2305,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const targetType = typeList.length === 0 ? types_1.UnknownType.create() : (0, types_1.combineTypes)(typeList);
             assignTypeToExpression(expr, targetType, isTypeIncomplete, srcExpr, /* ignoreEmptyContainers */ true);
         });
-        writeTypeCache(target, type, 0 /* None */, isTypeIncomplete);
+        writeTypeCache(target, { type, isIncomplete: isTypeIncomplete }, 0 /* None */);
     }
     // Replaces all of the top-level TypeVars (as opposed to TypeVars
     // used as type arguments in other types) with their concrete form.
@@ -2534,7 +2532,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     setErrorNode: srcExpr,
                     setExpectedTypeDiag: expectedTypeDiagAddendum,
                 }, 0 /* None */);
-                writeTypeCache(target, type, 0 /* None */, isTypeIncomplete);
+                writeTypeCache(target, { type, isIncomplete: isTypeIncomplete }, 0 /* None */);
                 break;
             }
             case 31 /* List */:
@@ -2657,14 +2655,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             case 35 /* MemberAccess */: {
                 const baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* DoNotSpecialize */);
                 const memberType = getTypeOfMemberAccessWithBaseType(node, baseTypeResult, { method: 'del' }, 0 /* None */);
-                writeTypeCache(node.memberName, memberType.type, 0 /* None */, /* isIncomplete */ false);
-                writeTypeCache(node, memberType.type, 0 /* None */, /* isIncomplete */ false);
+                writeTypeCache(node.memberName, { type: memberType.type }, 0 /* None */);
+                writeTypeCache(node, { type: memberType.type }, 0 /* None */);
                 break;
             }
             case 24 /* Index */: {
                 const baseTypeResult = getTypeOfExpression(node.baseExpression, 2 /* DoNotSpecialize */);
                 getTypeOfIndexWithBaseType(node, baseTypeResult, { method: 'del' }, 0 /* None */);
-                writeTypeCache(node, types_1.UnboundType.create(), 0 /* None */, /* isIncomplete */ false);
+                writeTypeCache(node, { type: types_1.UnboundType.create() }, 0 /* None */);
                 break;
             }
             case 52 /* Tuple */: {
@@ -3037,7 +3035,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (enclosingScope) {
                             // If the enclosing scope is using type parameter syntax, traditional
                             // type variables can't be used in this context.
-                            if (enclosingScope.typeParameters) {
+                            if (enclosingScope.typeParameters &&
+                                !enclosingScope.typeParameters.parameters.some((param) => param.name.value === type.details.name)) {
                                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeParameterNotDeclared().format({
                                     name: type.details.name,
                                     container: enclosingScope.name.value,
@@ -3273,8 +3272,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const typeResult = getTypeOfMemberAccessWithBaseType(node, baseTypeResult, { method: 'get' }, flags | 2 /* DoNotSpecialize */);
         if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(node)) {
             // Before performing code flow analysis, update the cache to prevent recursion.
-            writeTypeCache(node, typeResult.type, flags, /* isIncomplete */ true);
-            writeTypeCache(node.memberName, typeResult.type, flags, /* isIncomplete */ true);
+            writeTypeCache(node, { ...typeResult, isIncomplete: true }, flags);
+            writeTypeCache(node.memberName, { ...typeResult, isIncomplete: true }, flags);
             // If the type is initially unbound, see if there's a parent class that
             // potentially initialized the value.
             let typeAtStart = typeResult.type;
@@ -3314,7 +3313,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             typeResult.isIncomplete = true;
         }
         // Cache the type information in the member name node.
-        writeTypeCache(node.memberName, typeResult.type, flags, !!typeResult.isIncomplete);
+        writeTypeCache(node.memberName, typeResult, flags);
         return typeResult;
     }
     function getTypeOfMemberAccessWithBaseType(node, baseTypeResult, usage, flags) {
@@ -3687,7 +3686,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             // Don't include variables within typed dict classes.
-            if (types_1.ClassType.isTypedDictClass(classType)) {
+            if ((0, types_1.isClass)(memberInfo.classType) && types_1.ClassType.isTypedDictClass(memberInfo.classType)) {
                 const typedDecls = memberInfo.symbol.getTypedDeclarations();
                 if (typedDecls.length > 0 && typedDecls[0].type === 1 /* Variable */) {
                     diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberUnknown().format({ name: memberName }));
@@ -4193,7 +4192,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             if (baseTypeSupportsIndexNarrowing) {
                 // Before performing code flow analysis, update the cache to prevent recursion.
-                writeTypeCache(node, indexTypeResult.type, flags, /* isIncomplete */ false);
+                writeTypeCache(node, indexTypeResult, flags);
                 // See if we can refine the type based on code flow analysis.
                 const codeFlowTypeResult = getFlowTypeOfReference(node, symbol_1.indeterminateSymbolId, indexTypeResult.type, 
                 /* startNode */ undefined, {
@@ -5505,7 +5504,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             isTypeIncomplete = true;
         }
         return {
-            argumentErrors: false,
+            argumentErrors: finalCallResult.argumentErrors,
             isArgumentAnyOrUnknown: finalCallResult.isArgumentAnyOrUnknown,
             returnType: (0, types_1.combineTypes)(returnTypes),
             isTypeIncomplete,
@@ -5649,7 +5648,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Replace the result with an unknown type since we don't know
             // what overload should have been used.
             result.returnType = types_1.UnknownType.create();
-            return result;
+            return { ...result, argumentErrors: true };
         }
         return { argumentErrors: true, isTypeIncomplete: false };
     }
@@ -5927,10 +5926,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 useSpeculativeMode(errorNode, () => {
                     callResult = validateCallArguments(errorNode, argList, { type: constructorMethodType }, typeVarContext.clone(), skipUnknownArgCheck);
                 });
-                if (!(callResult === null || callResult === void 0 ? void 0 : callResult.argumentErrors)) {
+                if (!callResult.argumentErrors) {
                     // Call validateCallArguments again, this time without speculative
                     // mode, so any errors are reported.
-                    const callResult = validateCallArguments(errorNode, argList, { type: constructorMethodType }, typeVarContext, skipUnknownArgCheck);
+                    callResult = validateCallArguments(errorNode, argList, { type: constructorMethodType }, typeVarContext, skipUnknownArgCheck);
                     if (callResult.isTypeIncomplete) {
                         isTypeIncomplete = true;
                     }
@@ -7372,6 +7371,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let specializedReturnType = (0, typeUtils_1.addConditionToType)((0, typeUtils_1.applySolvedTypeVars)(returnType, typeVarContext, {
             unknownIfNotFound,
+            useUnknownOverDefault: skipUnknownArgCheck,
             eliminateUnsolvedInUnions,
         }), typeCondition);
         // If the final return type is an unpacked tuple, turn it into a normal (unpacked) tuple.
@@ -7591,7 +7591,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (argParam.argument &&
                 argParam.argument.name &&
                 !speculativeTypeTracker.isSpeculative(argParam.errorNode)) {
-                writeTypeCache(argParam.argument.name, expectedType || argType, 0 /* None */, isTypeIncomplete);
+                writeTypeCache(argParam.argument.name, { type: expectedType || argType, isIncomplete: isTypeIncomplete }, 0 /* None */);
             }
         }
         else {
@@ -7997,7 +7997,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             // Update the type cache so we don't attempt to re-evaluate this node.
             // The type doesn't matter, so use Any.
-            writeTypeCache(node, types_1.AnyType.create(), /* flags */ undefined, /* isIncomplete */ false);
+            writeTypeCache(node, { type: types_1.AnyType.create() }, /* flags */ undefined);
             return functionType;
         }
         else {
@@ -8297,7 +8297,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else if (node.operator === 6 /* BitwiseOr */) {
                 // If this is a bitwise or ("|"), use the type of the left operand. This allows
                 // us to support the case where a TypedDict is being updated with a dict expression.
-                expectedOperandType = leftType;
+                if ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isTypedDictClass(leftType)) {
+                    expectedOperandType = leftType;
+                }
             }
         }
         const rightTypeResult = getTypeOfExpression(rightExpression, flags, expectedOperandType);
@@ -9431,7 +9433,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         functionType.details.typeVarScopeId = getScopeIdForNode(node);
         // Pre-cache the incomplete function type in case the evaluation of the
         // lambda depends on itself.
-        writeTypeCache(node, functionType, 0 /* None */, /* isIncomplete */ true);
+        writeTypeCache(node, { type: functionType, isIncomplete: true }, 0 /* None */);
         let expectedFunctionTypes = [];
         if (expectedType) {
             (0, typeUtils_1.mapSubtypes)(expectedType, (subtype) => {
@@ -9468,8 +9470,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 paramType = types_1.FunctionType.getEffectiveParameterType(expectedFunctionType, index);
             }
             if (param.name) {
-                writeTypeCache(param.name, transformVariadicParamType(node, param.category, paramType), 0 /* None */, 
-                /* isIncomplete */ false);
+                writeTypeCache(param.name, { type: transformVariadicParamType(node, param.category, paramType) }, 0 /* None */);
             }
             if (param.defaultValue) {
                 // Evaluate the default value if it's present.
@@ -9534,8 +9535,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (speculativeTypeTracker.isSpeculative(node)) {
             useSpeculativeMode(node.expression, () => {
                 inferLambdaReturnType();
-            }, 
-            /* allowCacheRetention */ false);
+            });
         }
         else {
             inferLambdaReturnType();
@@ -10559,7 +10559,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 specialType.details.baseClasses.push(strClassType !== null && strClassType !== void 0 ? strClassType : types_1.AnyType.create());
                 (0, typeUtils_1.computeMroLinearization)(specialType);
             }
-            writeTypeCache(node, specialType, 0 /* None */, /* isIncomplete */ false);
+            writeTypeCache(node, { type: specialType }, 0 /* None */);
             return specialType;
         }
         return undefined;
@@ -10639,7 +10639,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (fileInfo.isTypingStubFile || fileInfo.isTypingExtensionsStubFile) {
                 rightHandType = handleTypingStubAssignment(node);
                 if (rightHandType) {
-                    writeTypeCache(node.rightExpression, rightHandType, 0 /* None */, /* isIncomplete */ false);
+                    writeTypeCache(node.rightExpression, { type: rightHandType }, 0 /* None */);
                 }
             }
             if (!rightHandType) {
@@ -10677,14 +10677,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     typeAliasTypeVar.details.recursiveTypeAliasScopeId = scopeId;
                     typeAliasTypeVar.scopeId = scopeId;
                     // Write the type back to the type cache. It will be replaced below.
-                    writeTypeCache(node, typeAliasTypeVar, /* flags */ undefined, /* isIncomplete */ false);
-                    writeTypeCache(node.leftExpression, typeAliasTypeVar, 
-                    /* flags */ undefined, 
-                    /* isIncomplete */ false);
+                    writeTypeCache(node, { type: typeAliasTypeVar }, /* flags */ undefined);
+                    writeTypeCache(node.leftExpression, { type: typeAliasTypeVar }, /* flags */ undefined);
                     if (node.leftExpression.nodeType === 54 /* TypeAnnotation */) {
-                        writeTypeCache(node.leftExpression.valueExpression, typeAliasTypeVar, 
-                        /* flags */ undefined, 
-                        /* isIncomplete */ false);
+                        writeTypeCache(node.leftExpression.valueExpression, { type: typeAliasTypeVar }, 
+                        /* flags */ undefined);
                     }
                 }
                 const srcTypeResult = getTypeOfExpression(node.rightExpression, flags, declaredType);
@@ -10753,7 +10750,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         assignTypeToExpression(node.leftExpression, rightHandType, isIncomplete, node.rightExpression, 
         /* ignoreEmptyContainers */ true, 
         /* allowAssignmentToFinalVar */ true, expectedTypeDiagAddendum);
-        writeTypeCache(node, rightHandType, 0 /* None */, isIncomplete);
+        writeTypeCache(node, { type: rightHandType, isIncomplete }, 0 /* None */);
     }
     function isPossibleTypeAliasOrTypedDict(decl) {
         var _a;
@@ -10800,7 +10797,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         typeAliasTypeVar.details.recursiveTypeAliasScopeId = scopeId;
         typeAliasTypeVar.scopeId = scopeId;
         // Write the type to the type cache. It will be replaced below.
-        writeTypeCache(node.name, typeAliasTypeVar, /* flags */ undefined, /* isIncomplete */ false);
+        writeTypeCache(node.name, { type: typeAliasTypeVar }, /* flags */ undefined);
         // Set a partial type to handle recursive (self-referential) type aliases.
         const scope = ScopeUtils.getScopeForNode(node);
         const typeAliasSymbol = scope === null || scope === void 0 ? void 0 : scope.lookUpSymbolRecursive(node.name.value);
@@ -10839,7 +10836,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 name: node.name.value,
             }), node.name);
         }
-        writeTypeCache(node.name, aliasType, 0 /* None */, isIncomplete);
+        writeTypeCache(node.name, { type: aliasType, isIncomplete }, 0 /* None */);
         return aliasType;
     }
     function evaluateTypesForAugmentedAssignment(node) {
@@ -10847,7 +10844,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return;
         }
         const destTypeResult = getTypeOfAugmentedAssignment(node, /* expectedType */ undefined);
-        writeTypeCache(node, destTypeResult.type, 0 /* None */, !!destTypeResult.isIncomplete);
+        writeTypeCache(node, destTypeResult, 0 /* None */);
     }
     function getPseudoGenericTypeVarName(paramName) {
         return `__type_of_${paramName}`;
@@ -10906,8 +10903,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             setSymbolResolutionPartialType(classSymbol, classDecl, classType);
         }
         classType.details.flags |= 131072 /* PartiallyEvaluated */;
-        writeTypeCache(node, classType, /* flags */ undefined, /* isIncomplete */ false);
-        writeTypeCache(node.name, classType, /* flags */ undefined, /* isIncomplete */ false);
+        writeTypeCache(node, { type: classType }, /* flags */ undefined);
+        writeTypeCache(node.name, { type: classType }, /* flags */ undefined);
         // Keep a list of unique type parameters that are used in the
         // base class arguments.
         let typeParameters = [];
@@ -11330,9 +11327,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         // Update the undecorated class type.
-        writeTypeCache(node.name, classType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node.name, { type: classType }, 0 /* None */);
         // Update the decorated class type.
-        writeTypeCache(node, decoratedType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node, { type: decoratedType }, 0 /* None */);
         // Stash away a reference to the UnionType class if we encounter it.
         // There's no easy way to otherwise reference it.
         if (types_1.ClassType.isBuiltIn(classType, 'UnionType')) {
@@ -11345,7 +11342,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // parameters and updates the scope of the type parameter referred to in the
     // default type expression.
     function validateTypeParameterDefault(errorNode, typeParam, otherLiveTypeParams) {
-        if (!typeParam.details.defaultType) {
+        if (!typeParam.details.defaultType &&
+            !typeParam.details.isSynthesized &&
+            !typeParam.details.isSynthesizedSelf) {
             const typeVarWithDefault = otherLiveTypeParams.find((param) => param.details.defaultType);
             if (typeVarWithDefault) {
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarWithoutDefault().format({
@@ -11444,7 +11443,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!typeOfParam || !(0, types_1.isTypeVar)(typeOfParam)) {
                 return;
             }
-            writeTypeCache(param.name, typeOfParam, 0 /* None */, /* isIncomplete */ false);
+            writeTypeCache(param.name, { type: typeOfParam }, 0 /* None */);
             paramTypes.push(typeOfParam);
         });
         return paramTypes;
@@ -11743,8 +11742,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (functionDecl && functionSymbol) {
             setSymbolResolutionPartialType(functionSymbol.symbol, functionDecl, functionType);
         }
-        writeTypeCache(node, functionType, /* flags */ undefined, /* isIncomplete */ false);
-        writeTypeCache(node.name, functionType, /* flags */ undefined, /* isIncomplete */ false);
+        writeTypeCache(node, { type: functionType }, /* flags */ undefined);
+        writeTypeCache(node.name, { type: functionType }, /* flags */ undefined);
         // Is this an "__init__" method within a pseudo-generic class? If so,
         // we'll add generic types to the constructor's parameters.
         const addGenericParamTypes = containingClassType &&
@@ -11954,7 +11953,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if ((0, types_1.isUnknown)(paramType)) {
                     functionType.details.flags |= 16384 /* UnannotatedParams */;
                 }
-                writeTypeCache(paramNameNode, paramType, 0 /* None */, /* isIncomplete */ false);
+                writeTypeCache(paramNameNode, { type: paramType }, 0 /* None */);
             }
         });
         // If the function ends in P.args and P.kwargs parameters, make it exempt from
@@ -12059,8 +12058,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             decoratedType = addOverloadsToFunctionType(node, decoratedType);
         }
-        writeTypeCache(node.name, functionType, 0 /* None */, /* isIncomplete */ false);
-        writeTypeCache(node, decoratedType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node.name, { type: functionType }, 0 /* None */);
+        writeTypeCache(node, { type: decoratedType }, 0 /* None */);
         return { functionType, decoratedType };
     }
     // If the declared return type of a function contains type variables that
@@ -12640,7 +12639,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                 }
-                writeTypeCache(node.suite, inferredReturnType, 0 /* None */, isIncomplete);
+                writeTypeCache(node.suite, { type: inferredReturnType, isIncomplete }, 0 /* None */);
             }
             finally {
                 functionRecursionMap.delete(node.id);
@@ -12683,7 +12682,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const iteratorTypeResult = getTypeOfExpression(node.iterableExpression);
         const iteratedType = (_b = (_a = getTypeOfIterator(iteratorTypeResult, !!node.isAsync, node.iterableExpression)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
         assignTypeToExpression(node.targetExpression, iteratedType, !!iteratorTypeResult.isIncomplete, node.targetExpression);
-        writeTypeCache(node, iteratedType, 0 /* None */, !!iteratorTypeResult.isIncomplete);
+        writeTypeCache(node, { type: iteratedType, isIncomplete: !!iteratorTypeResult.isIncomplete }, 0 /* None */);
     }
     function evaluateTypesForExceptStatement(node) {
         // This should be called only if the except node has a target exception.
@@ -12733,7 +12732,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (node.name) {
             assignTypeToExpression(node.name, targetType, /* isIncomplete */ false, node.name);
         }
-        writeTypeCache(node, targetType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node, { type: targetType }, 0 /* None */);
     }
     function evaluateTypesForWithStatement(node) {
         if (readTypeCache(node, 0 /* None */)) {
@@ -12798,7 +12797,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (node.target) {
             assignTypeToExpression(node.target, scopedType, !!exprTypeResult.isIncomplete, node.target);
         }
-        writeTypeCache(node, scopedType, 0 /* None */, !!exprTypeResult.isIncomplete);
+        writeTypeCache(node, { type: scopedType, isIncomplete: !!exprTypeResult.isIncomplete }, 0 /* None */);
     }
     function evaluateTypesForImportAs(node) {
         var _a;
@@ -12830,7 +12829,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         assignTypeToNameNode(symbolNameNode, symbolType, /* isIncomplete */ false, /* ignoreEmptyContainers */ false);
-        writeTypeCache(node, symbolType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node, { type: symbolType }, 0 /* None */);
     }
     function evaluateTypesForImportFromAs(node) {
         var _a;
@@ -12887,7 +12886,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         assignTypeToNameNode(aliasNode, symbolType, /* isIncomplete */ false, /* ignoreEmptyContainers */ false);
-        writeTypeCache(node, symbolType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node, { type: symbolType }, 0 /* None */);
     }
     function evaluateTypesForMatchStatement(node) {
         if (readTypeCache(node, 0 /* None */)) {
@@ -12902,7 +12901,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 /* isPositiveTest */ false);
             }
         }
-        writeTypeCache(node, subjectType, 0 /* None */, !!subjectTypeResult.isIncomplete);
+        writeTypeCache(node, { type: subjectType, isIncomplete: !!subjectTypeResult.isIncomplete }, 0 /* None */);
     }
     function evaluateTypesForCaseStatement(node) {
         if (readTypeCache(node, 0 /* None */)) {
@@ -12936,7 +12935,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         subjectType = (0, patternMatching_1.narrowTypeBasedOnPattern)(evaluatorInterface, subjectType, node.pattern, 
         /* isPositiveTest */ true);
         (0, patternMatching_1.assignTypeToPatternTargets)(evaluatorInterface, subjectType, !!subjectTypeResult.isIncomplete, subjectIsObject, node.pattern);
-        writeTypeCache(node, subjectType, 0 /* None */, !!subjectTypeResult.isIncomplete);
+        writeTypeCache(node, { type: subjectType, isIncomplete: !!subjectTypeResult.isIncomplete }, 0 /* None */);
     }
     function evaluateTypesForImportFrom(node) {
         if (readTypeCache(node, 0 /* None */)) {
@@ -12958,7 +12957,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         assignTypeToNameNode(symbolNameNode, symbolType, /* isIncomplete */ false, /* ignoreEmptyContainers */ false);
-        writeTypeCache(node, symbolType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node, { type: symbolType }, 0 /* None */);
     }
     function evaluateTypesForTypeAnnotationNode(node) {
         var _a;
@@ -12974,7 +12973,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(node.valueExpression),
                 allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(node.valueExpression),
             });
-            writeTypeCache(node.valueExpression, annotationType, 0 /* None */, /* isIncomplete */ false);
+            writeTypeCache(node.valueExpression, { type: annotationType }, 0 /* None */);
         }
     }
     function getAliasedSymbolTypeForName(node, name) {
@@ -13311,7 +13310,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const param = functionNode.parameters[paramIndex];
             const annotatedType = getTypeOfParameterAnnotation(typeAnnotation, functionNode.parameters[paramIndex].category);
             const adjType = transformVariadicParamType(node, node.category, adjustParameterAnnotatedType(param, annotatedType));
-            writeTypeCache(node.name, adjType, 0 /* None */, /* isIncomplete */ false);
+            writeTypeCache(node.name, { type: adjType }, 0 /* None */);
             return;
         }
         const containingClassNode = ParseTreeUtils.getEnclosingClass(functionNode, /* stopAtFunction */ true);
@@ -13322,7 +13321,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const typeParamName = getPseudoGenericTypeVarName(node.name.value);
             const paramType = classInfo.classType.details.typeParameters.find((param) => param.details.name === typeParamName);
             if (paramType) {
-                writeTypeCache(node.name, paramType, 0 /* None */, /* isIncomplete */ false);
+                writeTypeCache(node.name, { type: paramType }, 0 /* None */);
                 return;
             }
         }
@@ -13331,8 +13330,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // a parent class if it has an annotated type.
         const functionFlags = getFunctionFlagsFromDecorators(functionNode, /* isInClass */ true);
         const inferredParamType = inferParameterType(functionNode, functionFlags, paramIndex, classInfo === null || classInfo === void 0 ? void 0 : classInfo.classType);
-        writeTypeCache(node.name, transformVariadicParamType(node, node.category, inferredParamType !== null && inferredParamType !== void 0 ? inferredParamType : types_1.UnknownType.create()), 0 /* None */, 
-        /* isIncomplete */ false);
+        writeTypeCache(node.name, { type: transformVariadicParamType(node, node.category, inferredParamType !== null && inferredParamType !== void 0 ? inferredParamType : types_1.UnknownType.create()) }, 0 /* None */);
     }
     // Evaluates the types that are assigned within the statement that contains
     // the specified parse node. In some cases, a broader statement may need to
@@ -13445,13 +13443,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If the type cache is already populated with a complete type,
         // don't bother doing additional work.
         let cacheEntry = readTypeCacheEntry(subnode);
-        if (cacheEntry && !cacheEntry.isIncomplete) {
-            return { type: cacheEntry.type };
+        if (cacheEntry && !cacheEntry.typeResult.isIncomplete) {
+            return { type: cacheEntry.typeResult.type };
         }
         callback();
         cacheEntry = readTypeCacheEntry(subnode);
         if (cacheEntry) {
-            return { type: cacheEntry.type, isIncomplete: cacheEntry.isIncomplete };
+            return {
+                type: cacheEntry.typeResult.type,
+                isIncomplete: cacheEntry.typeResult.isIncomplete,
+                expectedTypeDiagAddendum: cacheEntry.typeResult.expectedTypeDiagAddendum,
+            };
         }
         return undefined;
     }
@@ -14002,8 +14004,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // Disables recording of errors and warnings and disables
     // any caching of types, under the assumption that we're
     // performing speculative evaluations.
-    function useSpeculativeMode(speculativeNode, callback, allowCacheRetention = true) {
-        speculativeTypeTracker.enterSpeculativeContext(speculativeNode, allowCacheRetention);
+    function useSpeculativeMode(speculativeNode, callback) {
+        speculativeTypeTracker.enterSpeculativeContext(speculativeNode);
         try {
             const result = callback();
             speculativeTypeTracker.leaveSpeculativeContext();
@@ -14381,8 +14383,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Cache the value before we evaluate the bound or the default type in
         // case it refers to itself in a circular manner.
-        writeTypeCache(node, typeVar, /* flags */ undefined, /* isIncomplete */ false);
-        writeTypeCache(node.name, typeVar, /* flags */ undefined, /* isIncomplete */ false);
+        writeTypeCache(node, { type: typeVar }, /* flags */ undefined);
+        writeTypeCache(node.name, { type: typeVar }, /* flags */ undefined);
         if (node.boundExpression) {
             if (node.boundExpression.nodeType === 52 /* Tuple */) {
                 const constraints = node.boundExpression.expressions.map((constraint) => {
@@ -14684,7 +14686,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return getEffectiveTypeOfSymbolForUsage(symbol).type;
     }
     function getEffectiveTypeOfSymbolForUsage(symbol, usageNode, useLastDecl = false) {
-        var _a;
+        var _a, _b;
         // If there's a declared type, it takes precedence over inferred types.
         if (symbol.hasTypedDeclarations()) {
             const declaredType = getDeclaredTypeOfSymbol(symbol, usageNode);
@@ -14708,7 +14710,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Look in the cache to see if we've computed this already.
         let cacheEntries = effectiveTypeCache.get(symbol.id);
-        let evaluationAttempts = 0;
         const usageNodeId = usageNode ? usageNode.id : undefined;
         const effectiveTypeCacheKey = `${usageNodeId === undefined ? '.' : usageNodeId.toString()}${useLastDecl ? '*' : ''}`;
         if (cacheEntries) {
@@ -14717,7 +14718,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (!result.isIncomplete) {
                     return result;
                 }
-                evaluationAttempts = ((_a = result.evaluationAttempts) !== null && _a !== void 0 ? _a : 0) + 1;
             }
         }
         // Infer the type.
@@ -14845,20 +14845,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     isIncomplete = true;
                     // Note that at least one decl could not be evaluated because
-                    // it was already in the process of being evaluated. Don't set
-                    // this flag if we've already attempted the type evaluation
-                    // many times because this probably means there's a cyclical
-                    // dependency that cannot be broken.
-                    if (evaluationAttempts < maxEffectiveTypeEvaluationAttempts) {
-                        sawPendingEvaluation = true;
-                    }
+                    // it was already in the process of being evaluated.
+                    sawPendingEvaluation = true;
                 }
             }
         });
         if (typesToCombine.length > 0) {
+            // How many times have we already attempted to evaluate this declaration already?
+            const evaluationAttempts = ((_b = (_a = cacheEntries === null || cacheEntries === void 0 ? void 0 : cacheEntries.get(effectiveTypeCacheKey)) === null || _a === void 0 ? void 0 : _a.evaluationAttempts) !== null && _b !== void 0 ? _b : 0) + 1;
+            // Ignore the pending evaluation flag if we've already attempted the
+            // type evaluation many times because this probably means there's a
+            // cyclical dependency that cannot be broken.
+            isIncomplete = sawPendingEvaluation && evaluationAttempts < maxEffectiveTypeEvaluationAttempts;
             const result = {
                 type: (0, types_1.combineTypes)(typesToCombine),
-                isIncomplete: sawPendingEvaluation,
+                isIncomplete,
                 includesVariableDecl,
                 includesIllegalTypeAliasDecl: !decls.every((decl) => (0, declarationUtils_1.isPossibleTypeAliasDeclaration)(decl)),
                 isRecursiveDefinition: false,
@@ -14880,7 +14881,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             includesVariableDecl,
             includesIllegalTypeAliasDecl: !decls.every((decl) => (0, declarationUtils_1.isPossibleTypeAliasDeclaration)(decl)),
             isRecursiveDefinition: false,
-            evaluationAttempts,
         };
     }
     function getDeclaredTypeOfSymbol(symbol, usageNode) {
@@ -15139,7 +15139,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             paramType = types_1.UnknownType.create();
                         }
                         paramTypes.push(paramType);
-                        writeTypeCache(param.name, paramType, 0 /* None */, /* isIncomplete */ false);
+                        writeTypeCache(param.name, { type: paramType }, 0 /* None */);
                     }
                 });
                 // Don't bother trying to determine the contextual return
@@ -16658,6 +16658,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (destDetails.argsIndex === undefined) {
             return;
         }
+        // If the *args parameter isn't an unpacked TypeVarTuple or tuple,
+        // we have nothing to do.
+        if (!(0, types_1.isUnpacked)(destDetails.params[destDetails.argsIndex].type)) {
+            return;
+        }
         // If the source doesn't have enough positional parameters, we have nothing to do.
         if (srcDetails.params.length < destDetails.argsIndex) {
             return;
@@ -16891,9 +16896,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // The converse situation is OK.
         if (!types_1.FunctionType.shouldSkipArgsKwargsCompatibilityCheck(destType) &&
             srcParamDetails.argsIndex === undefined &&
+            srcType.details.paramSpec === undefined &&
             destParamDetails.argsIndex !== undefined &&
-            !destParamDetails.hasUnpackedVariadicTypeVar &&
-            !targetIncludesParamSpec) {
+            !destParamDetails.hasUnpackedVariadicTypeVar) {
             diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.argsParamMissing().format({
                 paramName: (_h = destParamDetails.params[destParamDetails.argsIndex].param.name) !== null && _h !== void 0 ? _h : '',
             }));
@@ -17848,6 +17853,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     const evaluatorInterface = {
         runWithCancellationToken,
         getType,
+        getTypeResult,
         getCachedType,
         getTypeOfExpression,
         getTypeOfAnnotation,