@zzzen/pyright-internal 1.2.0-dev.20240616 → 1.2.0-dev.20240623

package/dist/analyzer/typeEvaluator.js

@@ -2143,15 +2143,38 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
     }
     function addDiagnosticWithSuppressionCheck(diagLevel, message, node, range) {
-        if (!isDiagnosticSuppressedForNode(node) && isNodeReachable(node)) {
+        var _a;
+        if (isDiagnosticSuppressedForNode(node)) {
+            // See if this node is suppressed but the diagnostic should be generated
+            // anyway so it can be used by the caller that requested the suppression.
+            const suppressionEntry = suppressedNodeStack.find((suppressedNode) => ParseTreeUtils.isNodeContainedWithin(node, suppressedNode.node) && suppressedNode.suppressedDiags);
+            (_a = suppressionEntry === null || suppressionEntry === void 0 ? void 0 : suppressionEntry.suppressedDiags) === null || _a === void 0 ? void 0 : _a.push(message);
+            return undefined;
+        }
+        if (isNodeReachable(node)) {
             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-            return fileInfo.diagnosticSink.addDiagnosticWithTextRange(diagLevel, message, range || node);
+            return fileInfo.diagnosticSink.addDiagnosticWithTextRange(diagLevel, message, range !== null && range !== void 0 ? range : node);
         }
         return undefined;
     }
     function isDiagnosticSuppressedForNode(node) {
-        return (suppressedNodeStack.some((suppressedNode) => ParseTreeUtils.isNodeContainedWithin(node, suppressedNode)) ||
-            speculativeTypeTracker.isSpeculative(node, /* ignoreIfDiagnosticsAllowed */ true));
+        if (speculativeTypeTracker.isSpeculative(node, /* ignoreIfDiagnosticsAllowed */ true)) {
+            return true;
+        }
+        return suppressedNodeStack.some((suppressedNode) => ParseTreeUtils.isNodeContainedWithin(node, suppressedNode.node));
+    }
+    // This function is similar to isDiagnosticSuppressedForNode except that it
+    // returns false if diagnostics are suppressed for the node but the caller
+    // has requested that diagnostics be generated anyway.
+    function canSkipDiagnosticForNode(node) {
+        if (speculativeTypeTracker.isSpeculative(node, /* ignoreIfDiagnosticsAllowed */ true)) {
+            return true;
+        }
+        const suppressedEntries = suppressedNodeStack.filter((suppressedNode) => ParseTreeUtils.isNodeContainedWithin(node, suppressedNode.node));
+        if (suppressedEntries.length === 0) {
+            return false;
+        }
+        return suppressedEntries.every((entry) => !entry.suppressedDiags);
     }
     function addDiagnostic(rule, message, node, range) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -4230,6 +4253,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             /* skipUnknownArgCheck */ true, 
             /* inferenceContext */ undefined, 
             /* signatureTracker */ undefined);
+        }, (suppressedDiags) => {
+            // If diagnostics were recorded when suppressed, add them to the
+            // diagnostic as messages.
+            if (diag) {
+                suppressedDiags.forEach((message) => {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessageMultiline(message);
+                });
+            }
         });
         // Collect deprecation information associated with the member access method.
         let deprecationInfo;
@@ -4252,28 +4283,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 memberAccessDeprecationInfo: deprecationInfo,
             };
         }
-        // Errors were detected when evaluating the access method call.
-        if (usage.method === 'set') {
-            if (usage.setType &&
-                (0, types_1.isFunction)(methodType) &&
-                methodType.details.parameters.length >= 2 &&
-                !usage.setType.isIncomplete) {
-                const setterType = types_1.FunctionType.getEffectiveParameterType(methodType, 1);
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeIncompatible().format({
-                    destType: printType(setterType),
-                    sourceType: printType(usage.setType.type),
-                }));
-            }
-            else if ((0, types_1.isOverloadedFunction)(methodType)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocMessage.noOverload().format({ name: accessMethodName }));
-            }
-        }
-        else {
-            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.descriptorAccessCallFailed().format({
-                name: accessMethodName,
-                className: printType((0, typeUtils_1.convertToInstance)(methodClassType)),
-            }));
-        }
         return {
             type: types_1.UnknownType.create(),
             typeErrors: true,
@@ -5179,7 +5188,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             });
             positionalIndexType = makeTupleObject(tupleTypeArgs);
         }
-        let argList = [
+        const argList = [
             {
                 argumentCategory: 0 /* ArgumentCategory.Simple */,
                 typeResult: { type: positionalIndexType, isIncomplete: isPositionalIndexTypeIncomplete },
@@ -5216,44 +5225,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 node: arg,
             });
         });
-        let callResult;
-        // 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.
-        if (keywordArgs.length === 0 && unpackedDictArgs.length === 0 && positionalArgs.length === 1) {
-            useSpeculativeMode(node, () => {
-                callResult = validateCallArguments(node, argList, { type: itemMethodType }, 
-                /* typeVarContext */ undefined, 
-                /* skipUnknownArgCheck */ true, 
-                /* inferenceContext */ undefined, 
-                /* signatureTracker */ undefined);
-                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 = getBoundMagicMethod(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 }, 
-                        /* typeVarContext */ undefined, 
-                        /* skipUnknownArgCheck */ true, 
-                        /* inferenceContext */ undefined, 
-                        /* signatureTracker */ undefined);
-                        // We were successful, so replace the arg list.
-                        if (!callResult.argumentErrors) {
-                            argList = altArgList;
-                        }
-                    }
-                }
-            });
-        }
-        callResult = validateCallArguments(node, argList, { type: itemMethodType }, 
+        const callResult = validateCallArguments(node, argList, { type: itemMethodType }, 
         /* typeVarContext */ undefined, 
         /* skipUnknownArgCheck */ true, 
         /* inferenceContext */ undefined, 
@@ -6398,7 +6370,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (filteredMatchResults.length === 0) {
             // Skip the error message if we're in speculative mode because it's very
             // expensive, and we're going to suppress the diagnostic anyway.
-            if (!isDiagnosticSuppressedForNode(errorNode)) {
+            if (!canSkipDiagnosticForNode(errorNode)) {
                 const functionName = typeResult.type.overloads[0].details.name || '<anonymous function>';
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                 const argTypes = argList.map((t) => {
@@ -6490,7 +6462,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // We couldn't find any valid overloads. Skip the error message if we're
         // in speculative mode because it's very expensive, and we're going to
         // suppress the diagnostic anyway.
-        if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+        if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
             const result = evaluateUsingBestMatchingOverload(
             /* skipUnknownArgCheck */ true, 
             /* emitNoOverloadFoundError */ true);
@@ -7250,7 +7222,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         tooManyPositionals = true;
                     }
                     if (tooManyPositionals) {
-                        if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                        if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, positionParamLimitIndex === 1
                                 ? localize_1.LocMessage.argPositionalExpectedOne()
                                 : localize_1.LocMessage.argPositionalExpectedCount().format({
@@ -7284,7 +7256,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if ((0, types_1.isTypeVar)(argTypeResult.type) &&
                         argTypeResult.type.paramSpecAccess === 'args' &&
                         paramDetails.params[paramIndex].param.category !== 1 /* ParameterCategory.ArgsList */) {
-                        if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                        if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, positionParamLimitIndex === 1
                                 ? localize_1.LocMessage.argPositionalExpectedOne()
                                 : localize_1.LocMessage.argPositionalExpectedCount().format({
@@ -7350,7 +7322,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // It's not allowed to use unpacked arguments with a variadic *args
                 // parameter unless the argument is a variadic arg as well.
                 if (isParamVariadic && !isArgCompatibleWithVariadic) {
-                    if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                    if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.unpackedArgWithVariadicParam(), argList[argIndex].valueExpression || errorNode);
                     }
                     reportedArgError = true;
@@ -7407,7 +7379,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         : 0 /* ParameterCategory.Simple */;
                     if (remainingArgCount <= remainingParamCount) {
                         if (remainingArgCount < remainingParamCount) {
-                            if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                            if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                                 // Have we run out of arguments and still have parameters left to fill?
                                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, remainingArgCount === 1
                                     ? localize_1.LocMessage.argMorePositionalExpectedOne()
@@ -7490,7 +7462,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 argsRemainingCount--;
             }
             if (argsRemainingCount > 0) {
-                if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, argsRemainingCount === 1
                         ? localize_1.LocMessage.argMorePositionalExpectedOne()
                         : localize_1.LocMessage.argMorePositionalExpectedCount().format({
@@ -7572,7 +7544,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             }
                         });
                         if (!diag.isEmpty()) {
-                            if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                            if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.unpackedTypedDictArgument() + diag.getString(), argList[argIndex].valueExpression || errorNode);
                             }
                             reportedArgError = true;
@@ -7632,7 +7604,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 });
                             }
                             if (!isValidMappingType) {
-                                if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                                if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.unpackedDictArgumentNotMapping(), argList[argIndex].valueExpression || errorNode);
                                 }
                                 reportedArgError = true;
@@ -7653,7 +7625,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         const paramEntry = paramMap.get(paramNameValue);
                         if (paramEntry && !paramEntry.isPositionalOnly) {
                             if (paramEntry.argsReceived > 0) {
-                                if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                                if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramAlreadyAssigned().format({ name: paramNameValue }), paramName);
                                 }
                                 reportedArgError = true;
@@ -7697,7 +7669,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             trySetActive(argList[argIndex], paramDetails.params[paramDetails.kwargsIndex].param);
                         }
                         else {
-                            if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                            if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramNameMissing().format({ name: paramName.value }), paramName);
                             }
                             reportedArgError = true;
@@ -7708,7 +7680,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             paramSpecArgList.push(argList[argIndex]);
                         }
                         else {
-                            if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                            if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, positionParamLimitIndex === 1
                                     ? localize_1.LocMessage.argPositionalExpectedOne()
                                     : localize_1.LocMessage.argPositionalExpectedCount().format({
@@ -7784,9 +7756,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return !entry || entry.argsReceived < entry.argsNeeded;
                 });
                 if (unassignedParams.length > 0) {
-                    if (!isDiagnosticSuppressedForNode(errorNode)) {
+                    if (!canSkipDiagnosticForNode(errorNode)) {
                         const missingParamNames = unassignedParams.map((p) => `"${p}"`).join(', ');
-                        if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                        if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, unassignedParams.length === 1
                                 ? localize_1.LocMessage.argMissingForParam().format({ name: missingParamNames })
                                 : localize_1.LocMessage.argMissingForParams().format({ names: missingParamNames }), errorNode);
@@ -7857,7 +7829,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (containsVariadicTypeVar &&
                             argParam.argument.argumentCategory !== 1 /* ArgumentCategory.UnpackedList */ &&
                             !argParam.mapsToVarArgList) {
-                            if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                            if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeVarTupleMustBeUnpacked(), (_a = argParam.argument.valueExpression) !== null && _a !== void 0 ? _a : errorNode);
                             }
                             reportedArgError = true;
@@ -8636,7 +8608,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // printing types if the diagnostic is disabled.
             const fileInfo = AnalyzerNodeInfo.getFileInfo(argParam.errorNode);
             if (fileInfo.diagnosticRuleSet.reportArgumentType !== 'none' &&
-                !isDiagnosticSuppressedForNode(argParam.errorNode) &&
+                !canSkipDiagnosticForNode(argParam.errorNode) &&
                 !isTypeIncomplete) {
                 const argTypeText = printType(argType);
                 const paramTypeText = printType(argParam.paramType);
@@ -10178,9 +10150,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }, {
                 dependentType: inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType,
-                allowDiagnostics: !forceSpeculative &&
-                    !isDiagnosticSuppressedForNode(node) &&
-                    !(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete),
+                allowDiagnostics: !forceSpeculative && !canSkipDiagnosticForNode(node) && !(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete),
             });
             // Mark the function type as no longer being evaluated.
             functionType.details.flags &= ~131072 /* FunctionTypeFlags.PartiallyEvaluated */;
@@ -14234,7 +14204,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         // Allocate a new code flow analyzer.
-        const analyzer = codeFlowEngine.createCodeFlowAnalyzer(typeAtStart);
+        const analyzer = codeFlowEngine.createCodeFlowAnalyzer();
         if (entries) {
             entries.push({ typeAtStart, codeFlowAnalyzer: analyzer });
         }
@@ -14327,6 +14297,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         0) {
                         addError(localize_1.LocMessage.protocolNotAllowed(), errorNode);
                     }
+                    typeArgs === null || typeArgs === void 0 ? void 0 : typeArgs.forEach((typeArg) => {
+                        if (typeArg.typeList || !(0, types_1.isTypeVar)(typeArg.type)) {
+                            addError(localize_1.LocMessage.protocolTypeArgMustBeTypeParam(), typeArg.node);
+                        }
+                    });
                     return {
                         type: createSpecialType(classType, typeArgs, 
                         /* paramLimit */ undefined, 
@@ -14445,18 +14420,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (firstDefaultParamIndex >= 0) {
                 minTypeArgCount = firstDefaultParamIndex;
             }
-            // Classes that accept inlined type dict type args allow only one.
-            if (typeArgs[0].inlinedTypeDict) {
-                if (typeArgs.length > 1) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsTooMany().format({
-                        name: classType.aliasName || classType.details.name,
-                        expected: 1,
-                        received: typeArgCount,
-                    }), typeArgs[1].node);
-                }
-                return { type: typeArgs[0].inlinedTypeDict };
-            }
-            else if (typeArgCount > typeParameters.length) {
+            if (typeArgCount > typeParameters.length) {
                 if (!types_1.ClassType.isPartiallyEvaluated(classType) && !types_1.ClassType.isTupleClass(classType)) {
                     if (typeParameters.length === 0) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsExpectingNone().format({
@@ -14839,11 +14803,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return symbolWithScope;
     }
     // Disables recording of errors and warnings.
-    function suppressDiagnostics(node, callback) {
-        suppressedNodeStack.push(node);
+    function suppressDiagnostics(node, callback, diagCallback) {
+        suppressedNodeStack.push({ node, suppressedDiags: diagCallback ? [] : undefined });
         try {
             const result = callback();
-            suppressedNodeStack.pop();
+            const poppedNode = suppressedNodeStack.pop();
+            if (diagCallback && (poppedNode === null || poppedNode === void 0 ? void 0 : poppedNode.suppressedDiags)) {
+                diagCallback(poppedNode.suppressedDiags);
+            }
             return result;
         }
         catch (e) {
@@ -16090,7 +16057,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const prevTypeCache = returnTypeInferenceTypeCache;
             returnTypeInferenceContextStack.push({
                 functionNode,
-                codeFlowAnalyzer: codeFlowEngine.createCodeFlowAnalyzer(/* typeAtStart */ undefined),
+                codeFlowAnalyzer: codeFlowEngine.createCodeFlowAnalyzer(),
             });
             try {
                 returnTypeInferenceTypeCache = new Map();
@@ -16503,6 +16470,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         while (destTypeArgs.length > srcTypeArgs.length && destTypeArgs[destTypeArgs.length - 1].isOptional) {
             destTypeArgs.splice(destTypeArgs.length - 1, 1);
         }
+        const srcArgsToCapture = srcTypeArgs.length - destTypeArgs.length + 1;
+        let skipAdjustSrc = false;
         // If we're doing reverse type mappings and the source contains a variadic
         // TypeVar, we need to adjust the dest so the reverse type mapping assignment
         // can be performed.
@@ -16528,10 +16497,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         isUnbounded: false,
                     });
                 }
+                skipAdjustSrc = true;
             }
         }
         else {
-            const srcArgsToCapture = srcTypeArgs.length - destTypeArgs.length + 1;
             if (destUnboundedOrVariadicIndex >= 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.
@@ -16560,30 +16529,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             isUnbounded: false,
                         });
                     }
+                    skipAdjustSrc = true;
                 }
-                else {
-                    // If possible, package up the source entries that correspond to
-                    // the dest unbounded tuple. This isn't possible if the source contains
-                    // an unbounded tuple outside of this range.
-                    if (srcUnboundedIndex < 0 ||
-                        (srcUnboundedIndex >= destUnboundedOrVariadicIndex &&
-                            srcUnboundedIndex < destUnboundedOrVariadicIndex + srcArgsToCapture)) {
-                        const removedArgTypes = srcTypeArgs
-                            .splice(destUnboundedOrVariadicIndex, 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(destUnboundedOrVariadicIndex, 0, {
-                            type: removedArgTypes.length > 0 ? (0, types_1.combineTypes)(removedArgTypes) : types_1.AnyType.create(),
-                            isUnbounded: false,
-                        });
+            }
+        }
+        if (!skipAdjustSrc && destUnboundedOrVariadicIndex >= 0 && srcArgsToCapture >= 0) {
+            // If possible, package up the source entries that correspond to
+            // the dest unbounded tuple. This isn't possible if the source contains
+            // an unbounded tuple outside of this range.
+            if (srcUnboundedIndex < 0 ||
+                (srcUnboundedIndex >= destUnboundedOrVariadicIndex &&
+                    srcUnboundedIndex < destUnboundedOrVariadicIndex + srcArgsToCapture)) {
+                const removedArgTypes = srcTypeArgs.splice(destUnboundedOrVariadicIndex, 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(destUnboundedOrVariadicIndex, 0, {
+                    type: removedArgTypes.length > 0 ? (0, types_1.combineTypes)(removedArgTypes) : types_1.AnyType.create(),
+                    isUnbounded: false,
+                });
             }
         }
         return destTypeArgs.length === srcTypeArgs.length;