@zzzen/pyright-internal 1.2.0-dev.20230827 → 1.2.0-dev.20230903

package/dist/analyzer/typeEvaluator.js

@@ -886,13 +886,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfString(node) {
         const isBytes = (node.token.flags & 32 /* Bytes */) !== 0;
         let typeResult;
+        let isIncomplete = false;
         // Don't create a literal type if it's an f-string.
         if (node.nodeType === 27 /* FormatString */) {
             let isLiteralString = true;
             // If all of the format expressions are of type LiteralString, then
             // the resulting formatted string is also LiteralString.
             node.fieldExpressions.forEach((expr) => {
-                const exprType = getTypeOfExpression(expr).type;
+                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;
@@ -910,18 +915,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!isBytes && isLiteralString) {
                 const literalStringType = getTypingType(node, 'LiteralString');
                 if (literalStringType && (0, types_1.isInstantiableClass)(literalStringType)) {
-                    typeResult = { type: types_1.ClassType.cloneAsInstance(literalStringType) };
+                    typeResult = { type: types_1.ClassType.cloneAsInstance(literalStringType), isIncomplete };
                 }
             }
             if (!typeResult) {
                 typeResult = {
                     type: getBuiltInObject(node, isBytes ? 'bytes' : 'str'),
+                    isIncomplete,
                 };
             }
         }
         else {
             typeResult = {
                 type: cloneBuiltinObjectWithLiteral(node, isBytes ? 'bytes' : 'str', node.value),
+                isIncomplete,
             };
         }
         return typeResult;
@@ -8242,15 +8249,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const condition = argType.condition;
         let diag = new diagnostic_1.DiagnosticAddendum();
-        // Handle the case where we're assigning a *args or **kwargs argument
-        // to a *P.args or **P.kwargs parameter.
-        if ((0, types_1.isParamSpec)(argParam.paramType) && argParam.paramType.paramSpecAccess !== undefined) {
-            return { isCompatible, argType, isTypeIncomplete, condition };
-        }
-        // Handle the case where we're assigning a *P.args or **P.kwargs argument
-        // to a *P.args or **P.kwargs parameter.
-        if ((0, types_1.isParamSpec)(argType) && argType.paramSpecAccess !== undefined) {
-            return { isCompatible, argType, isTypeIncomplete, condition };
+        if ((0, types_1.isParamSpec)(argParam.paramType)) {
+            // Handle the case where we're assigning a *args or **kwargs argument
+            // to a *P.args or **P.kwargs parameter.
+            if (argParam.paramType.paramSpecAccess !== undefined) {
+                return { isCompatible, argType, isTypeIncomplete, condition };
+            }
+            // Handle the case where we're assigning a *P.args or **P.kwargs argument
+            // to a *P.args or **P.kwargs parameter.
+            if ((0, types_1.isParamSpec)(argType) && argType.paramSpecAccess !== undefined) {
+                return { isCompatible, argType, isTypeIncomplete, condition };
+            }
         }
         // If we are asked to skip overload arguments, determine whether the argument
         // is an explicit overload type, an overloaded class constructor, or a
@@ -10141,7 +10150,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             if (!type) {
-                const exprType = getTypeOfExpression(itemExpr);
+                const exprType = getTypeOfExpression(itemExpr, flags & 4 /* AllowForwardReferences */);
                 // Is this an enum type?
                 if ((0, types_1.isClassInstance)(exprType.type) &&
                     types_1.ClassType.isEnumClass(exprType.type) &&
@@ -12852,6 +12861,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 setSymbolAccessed(fileInfo, symbolInScope.symbol, node);
             }
         }
+        // If this is an import into a class scope, mark the symbol as accessed.
+        const classNode = ParseTreeUtils.getEnclosingClass(node, /* stopAtFunction */ true);
+        if (classNode) {
+            const symbolInScope = lookUpSymbolRecursive(node, aliasNode.value, /* honorCodeFlow */ true);
+            if (symbolInScope) {
+                setSymbolAccessed(fileInfo, symbolInScope.symbol, node);
+            }
+        }
         let symbolType = getAliasedSymbolTypeForName(node, aliasNode.value);
         if (!symbolType) {
             const parentNode = node.parent;
@@ -14844,6 +14861,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     isIncomplete,
                     includesVariableDecl: typedDecls.some((decl) => decl.type === 1 /* Variable */),
                     includesIllegalTypeAliasDecl: !typedDecls.every((decl) => isPossibleTypeAliasDeclaration(decl)),
+                    includesSpeculativeResult: false,
                     isRecursiveDefinition: !declaredType,
                 };
                 return result;
@@ -14862,12 +14880,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         // Infer the type.
-        const typesToCombine = [];
         const decls = symbol.getDeclarations();
-        let isIncomplete = false;
-        let sawPendingEvaluation = false;
-        let includesVariableDecl = false;
-        let includesSpeculativeResult = false;
         let declIndexToConsider;
         // Limit the number of declarations to explore.
         if (decls.length > maxDeclarationsToUseForInference) {
@@ -14876,6 +14889,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 isIncomplete: false,
                 includesVariableDecl: false,
                 includesIllegalTypeAliasDecl: !decls.every((decl) => isPossibleTypeAliasDeclaration(decl)),
+                includesSpeculativeResult: false,
                 isRecursiveDefinition: false,
             };
             addToEffectiveTypeCache(result);
@@ -14902,22 +14916,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
+        // Determine which declarations to use for inference.
+        const declsToConsider = [];
         let sawExplicitTypeAlias = false;
         decls.forEach((decl, index) => {
             var _a, _b, _c;
-            let considerDecl = declIndexToConsider === undefined || index === declIndexToConsider;
+            if (declIndexToConsider !== undefined && declIndexToConsider !== index) {
+                return;
+            }
             // If we have already seen an explicit type alias, do not consider
             // additional decls. This can happen if multiple TypeAlias declarations
             // are provided -- normally an error, but it can happen in stdlib stubs
             // if the user sets the pythonPlatform to "All".
             if (sawExplicitTypeAlias) {
-                considerDecl = false;
+                return;
             }
             // If the symbol is explicitly marked as a ClassVar, consider only the
             // declarations that assign to it from within the class body, not through
             // a member access expression.
             if (symbol.isClassVar() && decl.type === 1 /* Variable */ && decl.isDefinedByMemberAccess) {
-                considerDecl = false;
+                return;
             }
             if (usageNode !== undefined) {
                 if (decl.type !== 8 /* Alias */) {
@@ -14926,122 +14944,133 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const declScope = ParseTreeUtils.getExecutionScopeNode(decl.node);
                     if (usageScope === declScope) {
                         if (!isFlowPathBetweenNodes(decl.node, usageNode)) {
-                            considerDecl = false;
+                            return;
                         }
                     }
                 }
             }
-            if (considerDecl) {
-                const resolvedDecl = (_a = resolveAliasDeclaration(decl, /* resolveLocalNames */ true, {
-                    allowExternallyHiddenAccess: AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile,
-                })) !== null && _a !== void 0 ? _a : decl;
-                const isExplicitTypeAlias = isExplicitTypeAliasDeclaration(resolvedDecl);
-                const isTypeAlias = isExplicitTypeAlias || isPossibleTypeAliasOrTypedDict(resolvedDecl);
-                if (isExplicitTypeAlias) {
-                    sawExplicitTypeAlias = true;
-                }
-                // If this is a type alias, evaluate it outside of the recursive symbol
-                // resolution check so we can evaluate the full assignment statement.
-                if (isTypeAlias &&
-                    resolvedDecl.type === 1 /* Variable */ &&
-                    ((_c = (_b = resolvedDecl.inferredTypeSource) === null || _b === void 0 ? void 0 : _b.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 3 /* Assignment */) {
-                    evaluateTypesForAssignmentStatement(resolvedDecl.inferredTypeSource.parent);
-                }
-                if (pushSymbolResolution(symbol, decl)) {
-                    try {
-                        let type = getInferredTypeOfDeclaration(symbol, decl);
-                        if (!popSymbolResolution(symbol)) {
-                            isIncomplete = true;
-                        }
-                        if (type) {
-                            if (resolvedDecl.type === 1 /* Variable */) {
-                                // Exempt typing.pyi, which uses variables to define some
-                                // special forms like Any.
-                                const fileInfo = AnalyzerNodeInfo.getFileInfo(resolvedDecl.node);
-                                if (!fileInfo.isTypingStubFile) {
-                                    includesVariableDecl = true;
-                                }
-                                let isConstant = false;
-                                if (resolvedDecl.type === 1 /* Variable */) {
-                                    if (resolvedDecl.isConstant || isFinalVariableDeclaration(resolvedDecl)) {
-                                        isConstant = true;
-                                    }
-                                }
-                                // Treat enum values declared within an enum class as though they are const even
-                                // though they may not be named as such.
-                                if ((0, types_1.isClassInstance)(type) &&
-                                    types_1.ClassType.isEnumClass(type) &&
-                                    (0, enums_1.isDeclInEnumClass)(evaluatorInterface, resolvedDecl)) {
+            const resolvedDecl = (_a = resolveAliasDeclaration(decl, /* resolveLocalNames */ true, {
+                allowExternallyHiddenAccess: AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile,
+            })) !== null && _a !== void 0 ? _a : decl;
+            const isExplicitTypeAlias = isExplicitTypeAliasDeclaration(resolvedDecl);
+            const isTypeAlias = isExplicitTypeAlias || isPossibleTypeAliasOrTypedDict(resolvedDecl);
+            if (isExplicitTypeAlias) {
+                sawExplicitTypeAlias = true;
+            }
+            // If this is a type alias, evaluate it outside of the recursive symbol
+            // resolution check so we can evaluate the full assignment statement.
+            if (isTypeAlias &&
+                resolvedDecl.type === 1 /* Variable */ &&
+                ((_c = (_b = resolvedDecl.inferredTypeSource) === null || _b === void 0 ? void 0 : _b.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 3 /* Assignment */) {
+                evaluateTypesForAssignmentStatement(resolvedDecl.inferredTypeSource.parent);
+            }
+            declsToConsider.push(resolvedDecl);
+        });
+        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;
+        const result = getTypeOfSymbolForDecls(symbol, declsToConsider, evaluationAttempts);
+        // Add the result to the effective type cache if it doesn't include speculative results.
+        if (!result.includesSpeculativeResult) {
+            addToEffectiveTypeCache(result);
+        }
+        return result;
+        function addToEffectiveTypeCache(result) {
+            // Add the entry to the cache so we don't need to compute it next time.
+            if (!cacheEntries) {
+                cacheEntries = new Map();
+                effectiveTypeCache.set(symbol.id, cacheEntries);
+            }
+            cacheEntries.set(effectiveTypeCacheKey, result);
+        }
+    }
+    // Returns the type of a symbol based on a subset of its declarations.
+    function getTypeOfSymbolForDecls(symbol, decls, evaluationAttempts) {
+        const typesToCombine = [];
+        let isIncomplete = false;
+        let sawPendingEvaluation = false;
+        let includesVariableDecl = false;
+        let includesSpeculativeResult = false;
+        decls.forEach((decl) => {
+            if (pushSymbolResolution(symbol, decl)) {
+                try {
+                    let type = getInferredTypeOfDeclaration(symbol, decl);
+                    if (!popSymbolResolution(symbol)) {
+                        isIncomplete = true;
+                    }
+                    if (type) {
+                        if (decl.type === 1 /* Variable */) {
+                            // Exempt typing.pyi, which uses variables to define some
+                            // special forms like Any.
+                            const fileInfo = AnalyzerNodeInfo.getFileInfo(decl.node);
+                            if (!fileInfo.isTypingStubFile) {
+                                includesVariableDecl = true;
+                            }
+                            let isConstant = false;
+                            if (decl.type === 1 /* Variable */) {
+                                if (decl.isConstant || isFinalVariableDeclaration(decl)) {
                                     isConstant = true;
                                 }
-                                // If the symbol is constant, we can retain the literal
-                                // value. Otherwise, strip literal values to widen the type.
-                                if (types_1.TypeBase.isInstance(type) && !isExplicitTypeAlias && !isConstant) {
-                                    type = stripLiteralValue(type);
-                                }
                             }
-                            typesToCombine.push(type);
-                            if (isSpeculativeModeInUse(decl.node)) {
-                                includesSpeculativeResult = true;
+                            // Treat enum values declared within an enum class as though they are const even
+                            // though they may not be named as such.
+                            if ((0, types_1.isClassInstance)(type) &&
+                                types_1.ClassType.isEnumClass(type) &&
+                                (0, enums_1.isDeclInEnumClass)(evaluatorInterface, decl)) {
+                                isConstant = true;
+                            }
+                            // If the symbol is constant, we can retain the literal
+                            // value. Otherwise, strip literal values to widen the type.
+                            if (types_1.TypeBase.isInstance(type) && !isConstant && !isExplicitTypeAliasDeclaration(decl)) {
+                                type = stripLiteralValue(type);
                             }
                         }
-                        else {
-                            isIncomplete = true;
+                        typesToCombine.push(type);
+                        if (isSpeculativeModeInUse(decl.node)) {
+                            includesSpeculativeResult = true;
                         }
                     }
-                    catch (e) {
-                        // Clean up the stack before rethrowing.
-                        popSymbolResolution(symbol);
-                        throw e;
+                    else {
+                        isIncomplete = true;
                     }
                 }
-                else {
-                    if (resolvedDecl.type === 6 /* Class */) {
-                        const classTypeInfo = getTypeOfClass(resolvedDecl.node);
-                        if (classTypeInfo === null || classTypeInfo === void 0 ? void 0 : classTypeInfo.decoratedType) {
-                            typesToCombine.push(classTypeInfo.decoratedType);
-                        }
+                catch (e) {
+                    // Clean up the stack before rethrowing.
+                    popSymbolResolution(symbol);
+                    throw e;
+                }
+            }
+            else {
+                if (decl.type === 6 /* Class */) {
+                    const classTypeInfo = getTypeOfClass(decl.node);
+                    if (classTypeInfo === null || classTypeInfo === void 0 ? void 0 : classTypeInfo.decoratedType) {
+                        typesToCombine.push(classTypeInfo.decoratedType);
                     }
-                    isIncomplete = true;
-                    // Note that at least one decl could not be evaluated because
-                    // it was already in the process of being evaluated.
-                    sawPendingEvaluation = true;
                 }
+                isIncomplete = true;
+                // Note that at least one decl could not be evaluated because
+                // it was already in the process of being evaluated.
+                sawPendingEvaluation = true;
             }
         });
-        // 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;
-        let resultType;
+        let type;
         if (typesToCombine.length > 0) {
             // 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;
-            resultType = (0, types_1.combineTypes)(typesToCombine);
+            type = (0, types_1.combineTypes)(typesToCombine);
         }
         else {
-            resultType = types_1.UnboundType.create();
+            type = types_1.UnboundType.create();
         }
-        const result = {
-            type: resultType,
+        return {
+            type,
             isIncomplete,
             includesVariableDecl,
             includesIllegalTypeAliasDecl: !decls.every((decl) => isPossibleTypeAliasDeclaration(decl)),
+            includesSpeculativeResult,
             isRecursiveDefinition: false,
             evaluationAttempts,
         };
-        if (!includesSpeculativeResult) {
-            addToEffectiveTypeCache(result);
-        }
-        return result;
-        function addToEffectiveTypeCache(result) {
-            // Add the entry to the cache so we don't need to compute it next time.
-            if (!cacheEntries) {
-                cacheEntries = new Map();
-                effectiveTypeCache.set(symbol.id, cacheEntries);
-            }
-            cacheEntries.set(effectiveTypeCacheKey, result);
-        }
     }
     // If a declaration has an explicit type (e.g. a variable with an annotation),
     // this function evaluates the type and returns it. If the symbol has no
@@ -15595,72 +15624,65 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         return isAssignable;
     }
-    // Adjusts the source type arguments list to match the length of the
-    // dest type arguments list if the dest list contains an unbounded
-    // or variadic entry.
-    function adjustSourceTupleTypeArgs(destTypeArgs, srcTypeArgs) {
-        const destVariadicIndex = destTypeArgs.findIndex((t) => (0, types_1.isVariadicTypeVar)(t.type));
-        const destUnboundedIndex = destTypeArgs.findIndex((t) => t.isUnbounded);
+    // Adjusts the source and/or dest type arguments list to attempt to match
+    // the length of the src type arguments list if the dest or source contain
+    // entries with indeterminate length or variadic entries. It returns true
+    // if the source is potentially compatible with the dest type, false otherwise.
+    function adjustSrcTupleTypeArgs(destTypeArgs, srcTypeArgs) {
+        const destUnboundedIndex = destTypeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isVariadicTypeVar)(t.type));
         const srcUnboundedIndex = srcTypeArgs.findIndex((t) => t.isUnbounded);
-        // If the source is unbounded, expand the unbounded argument to try
-        // to make the source and dest arg counts match.
+        // If the src contains an unbounded type but the dest does not, it's incompatible.
+        if (srcUnboundedIndex >= 0 && destUnboundedIndex < 0) {
+            return false;
+        }
         if (srcUnboundedIndex >= 0) {
+            // The source is unbounded, so expand the unbounded argument to try
+            // to make the source and dest arg counts match.
             const typeToReplicate = srcTypeArgs.length > 0 ? srcTypeArgs[srcUnboundedIndex].type : types_1.AnyType.create();
             while (srcTypeArgs.length < destTypeArgs.length) {
                 srcTypeArgs.splice(srcUnboundedIndex, 0, { type: typeToReplicate, isUnbounded: true });
             }
         }
-        // If the dest is unbounded or contains a variadic, determine which
-        // source args map to the unbounded or variadic arg.
-        if (destUnboundedIndex >= 0 || destVariadicIndex >= 0) {
-            // If there's a variadic within the destination, package up the corresponding
-            // source arguments into a tuple.
-            const srcArgsToCapture = srcTypeArgs.length - destTypeArgs.length + 1;
-            if (srcArgsToCapture >= 0) {
-                if (destVariadicIndex >= 0) {
-                    if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
-                        const removedArgs = srcTypeArgs.splice(destVariadicIndex, srcArgsToCapture);
-                        // Package up the remaining type arguments into a tuple object.
-                        const variadicTuple = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, removedArgs.map((typeArg) => {
-                            return { type: typeArg.type, isUnbounded: typeArg.isUnbounded };
-                        }), 
-                        /* isTypeArgumentExplicit */ true, 
-                        /* isUnpackedTuple */ true));
-                        srcTypeArgs.splice(destVariadicIndex, 0, {
-                            type: variadicTuple,
-                            isUnbounded: false,
-                        });
-                    }
-                }
-                else {
-                    const removedArgTypes = srcTypeArgs.splice(destUnboundedIndex, srcArgsToCapture).map((t) => {
-                        if ((0, types_1.isTypeVar)(t.type) && (0, types_1.isUnpackedVariadicTypeVar)(t.type) && !t.type.isVariadicInUnion) {
-                            return types_1.TypeVarType.cloneForUnpacked(t.type, /* isInUnion */ true);
-                        }
-                        return t.type;
-                    });
+        const srcArgsToCapture = srcTypeArgs.length - destTypeArgs.length + 1;
+        if (destUnboundedIndex >= 0 && srcArgsToCapture >= 0) {
+            // If the dest contains a variadic element, determine which source
+            // args map to this element and package them up into an unpacked tuple.
+            if ((0, types_1.isVariadicTypeVar)(destTypeArgs[destUnboundedIndex].type)) {
+                if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
+                    const removedArgs = srcTypeArgs.splice(destUnboundedIndex, srcArgsToCapture);
+                    // Package up the remaining type arguments into a tuple object.
+                    const variadicTuple = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, removedArgs.map((typeArg) => {
+                        return { type: typeArg.type, isUnbounded: typeArg.isUnbounded };
+                    }), 
+                    /* isTypeArgumentExplicit */ true, 
+                    /* isUnpackedTuple */ true));
                     srcTypeArgs.splice(destUnboundedIndex, 0, {
-                        type: removedArgTypes.length > 0 ? (0, types_1.combineTypes)(removedArgTypes) : types_1.AnyType.create(),
+                        type: variadicTuple,
                         isUnbounded: false,
                     });
                 }
             }
+            else {
+                const removedArgTypes = srcTypeArgs.splice(destUnboundedIndex, srcArgsToCapture).map((t) => {
+                    if ((0, types_1.isTypeVar)(t.type) && (0, types_1.isUnpackedVariadicTypeVar)(t.type) && !t.type.isVariadicInUnion) {
+                        return types_1.TypeVarType.cloneForUnpacked(t.type, /* isInUnion */ true);
+                    }
+                    return t.type;
+                });
+                srcTypeArgs.splice(destUnboundedIndex, 0, {
+                    type: removedArgTypes.length > 0 ? (0, types_1.combineTypes)(removedArgTypes) : types_1.AnyType.create(),
+                    isUnbounded: false,
+                });
+            }
         }
+        return destTypeArgs.length === srcTypeArgs.length;
     }
     function assignTupleTypeArguments(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         var _a, _b;
         const destTypeArgs = [...((_a = destType.tupleTypeArguments) !== null && _a !== void 0 ? _a : [])];
         const srcTypeArgs = [...((_b = srcType.tupleTypeArguments) !== null && _b !== void 0 ? _b : [])];
-        let srcUnboundedIndex;
-        if (flags & 2 /* ReverseTypeVarMatching */) {
-            adjustSourceTupleTypeArgs(srcTypeArgs, destTypeArgs);
-            srcUnboundedIndex = destTypeArgs.findIndex((t) => t.isUnbounded);
-        }
-        else {
-            adjustSourceTupleTypeArgs(destTypeArgs, srcTypeArgs);
-            srcUnboundedIndex = srcTypeArgs.findIndex((t) => t.isUnbounded);
-        }
-        if (srcTypeArgs.length === destTypeArgs.length) {
+        const reverseMapping = (flags & 2 /* ReverseTypeVarMatching */) !== 0;
+        if (adjustSrcTupleTypeArgs(reverseMapping ? srcTypeArgs : destTypeArgs, reverseMapping ? destTypeArgs : srcTypeArgs)) {
             for (let argIndex = 0; argIndex < srcTypeArgs.length; argIndex++) {
                 const entryDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
                 if (!assignType(destTypeArgs[argIndex].type, srcTypeArgs[argIndex].type, entryDiag === null || entryDiag === void 0 ? void 0 : entryDiag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
@@ -15674,13 +15696,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         else {
-            if (srcUnboundedIndex < 0) {
+            if (srcTypeArgs.find((t) => t.isUnbounded)) {
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.tupleSizeIndeterminate().format({
+                    expected: destTypeArgs.length,
+                }));
+            }
+            else {
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.tupleSizeMismatch().format({
                     expected: destTypeArgs.length,
                     received: srcTypeArgs.length,
                 }));
-                return false;
             }
+            return false;
         }
         return true;
     }
@@ -15939,7 +15966,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isTypeVar)(destType)) {
             if ((0, typeUtils_1.isTypeVarSame)(destType, srcType)) {
                 if (destType.scopeId && (destTypeVarContext === null || destTypeVarContext === void 0 ? void 0 : destTypeVarContext.hasSolveForScope(destType.scopeId))) {
-                    return (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, destType, srcType, diag, destTypeVarContext, flags, recursionCount);
+                    // If the dest TypeVar has no current value bound to it, bind itself.
+                    if (!destTypeVarContext.getPrimarySignature().getTypeVar(destType)) {
+                        return (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, destType, srcType, diag, destTypeVarContext, flags, recursionCount);
+                    }
                 }
                 return true;
             }
@@ -16040,6 +16070,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     destType.details.parameters.length <= 2) {
                     return true;
                 }
+                // If the source is an unpacked TypeVarTuple and the dest is a
+                // *tuple[Any, ...], we'll treat it as compatible.
+                if ((0, types_1.isUnpackedVariadicTypeVar)(srcType) &&
+                    (0, types_1.isClassInstance)(destType) &&
+                    (0, types_1.isUnpackedClass)(destType) &&
+                    destType.tupleTypeArguments &&
+                    destType.tupleTypeArguments.length === 1 &&
+                    destType.tupleTypeArguments[0].isUnbounded &&
+                    (0, types_1.isAnyOrUnknown)(destType.tupleTypeArguments[0].type)) {
+                    return true;
+                }
                 if (!(0, types_1.isUnion)(destType)) {
                     diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
                     return false;
@@ -17770,8 +17811,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (!targetParamType) {
                         targetParamType = overrideParamDetails.params[overrideParamDetails.kwargsIndex].type;
                     }
-                    if (!assignType(targetParamType, paramInfo.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 
-                    /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */)) {
+                    if (!assignType(targetParamType, paramInfo.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* SkipSolveTypeVars */)) {
                         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordType().format({
                             name: (_b = paramInfo.param.name) !== null && _b !== void 0 ? _b : '?',
                             baseType: printType(paramInfo.type),
@@ -17829,8 +17869,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Now check the return type.
         const baseReturnType = getFunctionEffectiveReturnType(baseMethod);
         const overrideReturnType = getFunctionEffectiveReturnType(overrideMethod);
-        if (!assignType(baseReturnType, overrideReturnType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 
-        /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */)) {
+        if (!assignType(baseReturnType, overrideReturnType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 8 /* SkipSolveTypeVars */)) {
             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideReturnType().format({
                 baseType: printType(baseReturnType),
                 overrideType: printType(overrideReturnType),