@zzzen/pyright-internal 1.2.0-dev.20240811 → 1.2.0-dev.20240818

package/dist/analyzer/typeEvaluator.js

@@ -56,6 +56,7 @@ const analyzerFileInfo_1 = require("./analyzerFileInfo");
 const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
 const codeFlowEngine_1 = require("./codeFlowEngine");
 const codeFlowTypes_1 = require("./codeFlowTypes");
+const constraintSolution_1 = require("./constraintSolution");
 const constraintSolver_1 = require("./constraintSolver");
 const constraintTracker_1 = require("./constraintTracker");
 const constructors_1 = require("./constructors");
@@ -3410,7 +3411,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 else if ((0, types_1.isTypeVarTuple)(param) && tupleClass && (0, types_1.isInstantiableClass)(tupleClass)) {
                     defaultType = makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }], 
-                    /* isUnpackedTuple */ true);
+                    /* isUnpacked */ true);
                 }
                 else {
                     defaultType = types_1.UnknownType.create();
@@ -3789,8 +3790,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (usage.method === 'get') {
                         const getAttrSymbol = types_1.ModuleType.getField(baseType, '__getattr__');
                         if (getAttrSymbol) {
-                            const isModuleGetAttrSupported = fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(pythonVersion_1.pythonVersion3_7) ||
-                                getAttrSymbol.getDeclarations().some((decl) => decl.uri.hasExtension('.pyi'));
+                            const isModuleGetAttrSupported = pythonVersion_1.PythonVersion.isGreaterOrEqualTo(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_7) || getAttrSymbol.getDeclarations().some((decl) => decl.uri.hasExtension('.pyi'));
                             if (isModuleGetAttrSupported) {
                                 const getAttrTypeResult = getEffectiveTypeOfSymbolForUsage(getAttrSymbol);
                                 if ((0, types_1.isFunction)(getAttrTypeResult.type)) {
@@ -4550,7 +4550,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     !baseTypeResult.type.priv.aliasName) {
                     const minPythonVersion = nonSubscriptableBuiltinTypes.get(baseTypeResult.type.shared.fullName);
                     if (minPythonVersion !== undefined &&
-                        fileInfo.executionEnvironment.pythonVersion.isLessThan(minPythonVersion) &&
+                        pythonVersion_1.PythonVersion.isLessThan(fileInfo.executionEnvironment.pythonVersion, minPythonVersion) &&
                         !fileInfo.isStubFile) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIndexIssue, localize_1.LocMessage.classNotRuntimeSubscriptable().format({
                             name: baseTypeResult.type.priv.aliasName || baseTypeResult.type.shared.name,
@@ -4687,7 +4687,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             }
                         });
                     }
-                    const tupleObject = makeTupleObject(variadicTypes, /* isUnpackedTuple */ true);
+                    const tupleObject = makeTupleObject(variadicTypes, /* isUnpacked */ true);
                     typeArgs = [
                         ...typeArgs.slice(0, variadicIndex),
                         { node: typeArgs[variadicIndex].node, type: tupleObject },
@@ -4699,7 +4699,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // Add an empty tuple that maps to the TypeVarTuple type parameter.
                 typeArgs.push({
                     node: errorNode,
-                    type: makeTupleObject([], /* isUnpackedTuple */ true),
+                    type: makeTupleObject([], /* isUnpacked */ true),
                 });
             }
         }
@@ -5148,9 +5148,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         });
     }
-    function makeTupleObject(typeArgs, isUnpackedTuple = false) {
+    function makeTupleObject(typeArgs, isUnpacked = false) {
         if (tupleClass && (0, types_1.isInstantiableClass)(tupleClass)) {
-            return (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClass, typeArgs, /* isTypeArgExplicit */ true, isUnpackedTuple));
+            return (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClass, typeArgs, /* isTypeArgExplicit */ true, isUnpacked));
         }
         return types_1.UnknownType.create();
     }
@@ -7196,7 +7196,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 else {
                     positionalOnlyLimitIndex = varArgListParamIndex;
-                    positionalArgCount = varArgListParamIndex;
+                    positionalArgCount = Math.min(varArgListParamIndex, positionalArgCount);
                     positionParamLimitIndex = varArgListParamIndex;
                 }
             }
@@ -7930,7 +7930,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         specializedTuple = tupleTypeArgs[0].type;
                     }
                     else {
-                        specializedTuple = makeTupleObject(tupleTypeArgs, /* isUnpackedTuple */ true);
+                        specializedTuple = makeTupleObject(tupleTypeArgs, /* isUnpacked */ true);
                     }
                     const combinedArg = {
                         paramCategory: 1 /* ParamCategory.ArgsList */,
@@ -8263,10 +8263,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // If the final return type is an unpacked tuple, turn it into a normal (unpacked) tuple.
         if ((0, types_1.isUnpackedClass)(specializedReturnType)) {
-            specializedReturnType = types_1.ClassType.cloneForUnpacked(specializedReturnType, /* isUnpackedTuple */ false);
+            specializedReturnType = types_1.ClassType.cloneForUnpacked(specializedReturnType, /* isUnpacked */ false);
         }
         const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
-        specializedReturnType = adjustCallableReturnType(type, specializedReturnType, liveTypeVarScopes);
+        specializedReturnType = adjustCallableReturnType(errorNode, specializedReturnType, liveTypeVarScopes);
         if (specializedInitSelfType) {
             specializedInitSelfType = solveAndApplyConstraints(specializedInitSelfType, constraints);
         }
@@ -8313,21 +8313,30 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // to allow these type vars to be solved. This won't work with overloads
     // or unions of callables. It's intended for a specific use case. We may
     // need to make this more sophisticated in the future.
-    function adjustCallableReturnType(callableType, returnType, liveTypeVarScopes) {
-        var _a, _b;
-        if (!(0, types_1.isFunction)(returnType) || returnType.shared.name || !callableType.shared.typeVarScopeId) {
+    function adjustCallableReturnType(callNode, returnType, liveTypeVarScopes) {
+        if (!(0, types_1.isFunction)(returnType)) {
             return returnType;
         }
         // What type variables are referenced in the callable return type? Do not include any live type variables.
-        const newTypeParams = (0, typeUtils_1.getTypeVarArgsRecursive)(returnType).filter((t) => !liveTypeVarScopes.some((scopeId) => t.priv.scopeId === scopeId));
+        const typeParams = (0, typeUtils_1.getTypeVarArgsRecursive)(returnType).filter((t) => !liveTypeVarScopes.some((scopeId) => t.priv.scopeId === scopeId));
         // If there are no unsolved type variables, we're done. If there are
-        // unsolved type variables, treat them as though they are rescoped
-        // to the callable.
-        if (newTypeParams.length === 0) {
+        // unsolved type variables, rescope them to the callable.
+        if (typeParams.length === 0) {
             return returnType;
         }
-        const newScopeId = (_b = (_a = newTypeParams[0].priv.freeTypeVar) === null || _a === void 0 ? void 0 : _a.priv.scopeId) !== null && _b !== void 0 ? _b : newTypeParams[0].priv.scopeId;
-        return types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, newScopeId, callableType.priv.constructorTypeVarScopeId, newTypeParams);
+        inferReturnTypeIfNecessary(returnType);
+        // Create a new scope ID based on the caller's position. This
+        // will guarantee uniqueness. If another caller uses the same
+        // call and arguments, the type vars will not conflict.
+        const newScopeId = ParseTreeUtils.getScopeIdForNode(callNode);
+        const solution = new constraintSolution_1.ConstraintSolution();
+        const newTypeParams = typeParams.map((typeVar) => {
+            const newTypeParam = types_1.TypeVarType.cloneForScopeId(typeVar, newScopeId, typeVar.priv.scopeName, 1 /* TypeVarScopeType.Function */);
+            solution.setType(typeVar, newTypeParam);
+            return newTypeParam;
+        });
+        return (0, typeUtils_1.applySolvedTypeVars)(types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, newScopeId, 
+        /* constructorTypeVarScopeId */ undefined, newTypeParams), solution);
     }
     // Tries to assign the call arguments to the function parameter
     // list and reports any mismatches in types or counts. Returns the
@@ -8746,7 +8755,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     typeVar.shared.isDefaultExplicit = true;
                     const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
                     if (!fileInfo.isStubFile &&
-                        fileInfo.executionEnvironment.pythonVersion.isLessThan(pythonVersion_1.pythonVersion3_13) &&
+                        pythonVersion_1.PythonVersion.isLessThan(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_13) &&
                         classType.shared.moduleName !== 'typing_extensions') {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultIllegal(), defaultValueNode);
                     }
@@ -8850,7 +8859,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
                     if (!fileInfo.isStubFile &&
-                        fileInfo.executionEnvironment.pythonVersion.isLessThan(pythonVersion_1.pythonVersion3_13) &&
+                        pythonVersion_1.PythonVersion.isLessThan(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_13) &&
                         classType.shared.moduleName !== 'typing_extensions') {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultIllegal(), expr);
                     }
@@ -8911,7 +8920,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
                     if (!fileInfo.isStubFile &&
-                        fileInfo.executionEnvironment.pythonVersion.isLessThan(pythonVersion_1.pythonVersion3_13) &&
+                        pythonVersion_1.PythonVersion.isLessThan(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_13) &&
                         classType.shared.moduleName !== 'typing_extensions') {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultIllegal(), expr);
                     }
@@ -10614,10 +10623,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return type;
     }
-    // Creates a "TypeGuard" and "TypeIs" type. This is an alias for 'bool', which
-    // isn't a generic type and therefore doesn't have a typeParam.
-    // We'll abuse our internal types a bit by specializing it with
-    // a type argument anyway.
+    // Creates a "TypeGuard" and "TypeIs" type.
     function createTypeGuardType(classType, errorNode, typeArgs, flags) {
         // If no type arguments are provided, the resulting type
         // depends on whether we're evaluating a type annotation or
@@ -11043,36 +11049,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             })) {
                 typeArgType = types_1.UnknownType.create();
             }
-            // If this is an unpacked tuple, explode out the individual items.
-            if ((0, types_1.isUnpackedClass)(typeArg.type) && typeArg.type.priv.tupleTypeArgs) {
+            if ((0, types_1.isTypeVar)(typeArgType) && (0, types_1.isUnpackedTypeVarTuple)(typeArgType)) {
                 // This is an experimental feature because Unions of unpacked TypeVarTuples are not officially supported.
                 if (fileInfo.diagnosticRuleSet.enableExperimentalFeatures) {
-                    typeArg.type.priv.tupleTypeArgs.forEach((tupleTypeArg) => {
-                        types.push((0, typeUtils_1.convertToInstantiable)(tupleTypeArg.type));
-                    });
+                    // If this is an unpacked TypeVar, note that it is in a union so we can
+                    // differentiate between Unpack[Vs] and Union[Unpack[Vs]].
+                    typeArgType = types_1.TypeVarType.cloneForUnpacked(typeArgType, /* isInUnion */ true);
                     allowSingleTypeArg = true;
                 }
                 else {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unionUnpackedTuple(), errorNode);
-                    types.push(types_1.UnknownType.create());
-                }
-            }
-            else {
-                if ((0, types_1.isTypeVar)(typeArgType) && (0, types_1.isUnpackedTypeVarTuple)(typeArgType)) {
-                    // This is an experimental feature because Unions of unpacked TypeVarTuples are not officially supported.
-                    if (fileInfo.diagnosticRuleSet.enableExperimentalFeatures) {
-                        // If this is an unpacked TypeVar, note that it is in a union so we can
-                        // differentiate between Unpack[Vs] and Union[Unpack[Vs]].
-                        typeArgType = types_1.TypeVarType.cloneForUnpacked(typeArgType, /* isInUnion */ true);
-                        allowSingleTypeArg = true;
-                    }
-                    else {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unionUnpackedTypeVarTuple(), errorNode);
-                        typeArgType = types_1.UnknownType.create();
-                    }
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unionUnpackedTypeVarTuple(), errorNode);
+                    typeArgType = types_1.UnknownType.create();
                 }
-                types.push(typeArgType);
             }
+            types.push(typeArgType);
         }
         // Validate that we received at least two type arguments. One type argument
         // is allowed if it's an unpacked TypeVarTuple or tuple. None is also allowed
@@ -11229,7 +11219,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (fileInfo.isTypingExtensionsStubFile) {
             specialClassType.shared.flags |= 4096 /* ClassTypeFlags.TypingExtensionClass */;
         }
-        const baseClassName = aliasMapEntry.alias || 'object';
+        const baseClassName = aliasMapEntry.implicitBaseClass || aliasMapEntry.alias || 'object';
         let baseClass;
         if (aliasMapEntry.module === 'builtins') {
             baseClass = getBuiltInType(node, baseClassName);
@@ -11296,7 +11286,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             ['Concatenate', { alias: '', module: 'builtins', isSpecialForm: true }],
             [
                 'TypeGuard',
-                { alias: '', module: 'builtins', isSpecialForm: true, typeParamVariance: 3 /* Variance.Covariant */ },
+                {
+                    alias: '',
+                    module: 'builtins',
+                    implicitBaseClass: 'bool',
+                    isSpecialForm: true,
+                    typeParamVariance: 3 /* Variance.Covariant */,
+                },
             ],
             ['Unpack', { alias: '', module: 'builtins', isSpecialForm: true }],
             ['Required', { alias: '', module: 'builtins', isSpecialForm: true }],
@@ -11306,7 +11302,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             ['Never', { alias: '', module: 'builtins', isSpecialForm: true }],
             ['LiteralString', { alias: '', module: 'builtins', isSpecialForm: true }],
             ['ReadOnly', { alias: '', module: 'builtins', isSpecialForm: true }],
-            ['TypeIs', { alias: '', module: 'builtins', isSpecialForm: true, typeParamVariance: 2 /* Variance.Invariant */ }],
+            [
+                'TypeIs',
+                {
+                    alias: '',
+                    module: 'builtins',
+                    implicitBaseClass: 'bool',
+                    isSpecialForm: true,
+                    typeParamVariance: 2 /* Variance.Invariant */,
+                },
+            ],
         ]);
         const aliasMapEntry = specialTypes.get(assignedName);
         if (aliasMapEntry) {
@@ -11743,7 +11748,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             if (types_1.ClassType.isBuiltIn(argType, 'Protocol')) {
                                 if (!fileInfo.isStubFile &&
                                     !types_1.ClassType.isTypingExtensionClass(argType) &&
-                                    fileInfo.executionEnvironment.pythonVersion.isLessThan(pythonVersion_1.pythonVersion3_7)) {
+                                    pythonVersion_1.PythonVersion.isLessThan(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_7)) {
                                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.protocolIllegal(), arg.d.valueExpr);
                                 }
                                 classType.shared.flags |= 512 /* ClassTypeFlags.ProtocolClass */;
@@ -11753,7 +11758,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             }
                             // If the class directly derives from NamedTuple (in Python 3.6 or
                             // newer), it's considered a (read-only) dataclass.
-                            if (fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(pythonVersion_1.pythonVersion3_6)) {
+                            if (pythonVersion_1.PythonVersion.isGreaterOrEqualTo(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_6)) {
                                 if (types_1.ClassType.isBuiltIn(argType, 'NamedTuple')) {
                                     isNamedTupleSubclass = true;
                                     classType.shared.flags |= 524288 /* ClassTypeFlags.ReadOnlyInstanceVariables */;
@@ -13064,7 +13069,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return type;
                 }
                 if ((0, types_1.isUnpackedClass)(type)) {
-                    return types_1.ClassType.cloneForUnpacked(type, /* isUnpackedTuple */ false);
+                    return types_1.ClassType.cloneForUnpacked(type, /* isUnpacked */ false);
                 }
                 return makeTupleObject([{ type, isUnbounded: !(0, types_1.isTypeVarTuple)(type) }]);
             }
@@ -13531,7 +13536,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     reportError = true;
                     // Handle PEP 562 support for module-level __getattr__ function,
                     // introduced in Python 3.7.
-                    if (fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(pythonVersion_1.pythonVersion3_7) ||
+                    if (pythonVersion_1.PythonVersion.isGreaterOrEqualTo(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_7) ||
                         fileInfo.isStubFile) {
                         const getAttrSymbol = importLookupInfo.symbolTable.get('__getattr__');
                         if (getAttrSymbol) {
@@ -14360,7 +14365,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
         if (fileInfo.isStubFile ||
-            fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(pythonVersion_1.pythonVersion3_9) ||
+            pythonVersion_1.PythonVersion.isGreaterOrEqualTo(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_9) ||
             (0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(AnalyzerNodeInfo.getFileInfo(errorNode)) ||
             (flags & 4 /* EvalFlags.ForwardRefs */) !== 0) {
             // Handle "type" specially, since it needs to act like "Type"
@@ -16374,13 +16379,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             return true;
         }
-        // If the type is a bool created with a `TypeGuard` or `TypeIs`, it is
-        // considered a subtype of `bool`.
-        if ((0, types_1.isInstantiableClass)(srcType) && types_1.ClassType.isBuiltIn(srcType, ['TypeGuard', 'TypeIs'])) {
-            if ((0, types_1.isInstantiableClass)(destType) && types_1.ClassType.isBuiltIn(destType, 'bool')) {
-                return (flags & 1 /* AssignTypeFlags.Invariant */) === 0;
-            }
-        }
         if ((flags & 1 /* AssignTypeFlags.Invariant */) === 0 || types_1.ClassType.isSameGenericClass(srcType, destType)) {
             if (isDerivedFrom) {
                 (0, debug_1.assert)(inheritanceChain.length > 0);
@@ -16616,7 +16614,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const typeParam = destType.shared.typeParams[i];
                 const variance = types_1.TypeVarType.getVariance(typeParam);
                 if (curSrcType.priv.tupleTypeArgs) {
-                    typeArgType = (0, typeUtils_1.convertToInstance)(makeTupleObject(curSrcType.priv.tupleTypeArgs, /* isUnpackedTuple */ true));
+                    typeArgType = (0, typeUtils_1.convertToInstance)(makeTupleObject(curSrcType.priv.tupleTypeArgs, /* isUnpacked */ true));
                 }
                 else {
                     typeArgType = i < srcTypeArgs.length ? srcTypeArgs[i] : types_1.UnknownType.create();
@@ -17733,7 +17731,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         }
-        return getBoundMagicMethod(objType, '__call__', /* selfType */ undefined, /* diag */ undefined, recursionCount);
+        const callType = getBoundMagicMethod(objType, '__call__', 
+        /* selfType */ undefined, 
+        /* diag */ undefined, recursionCount);
+        if (!callType) {
+            return undefined;
+        }
+        return (0, typeUtils_1.makeFunctionTypeVarsBound)(callType);
     }
     function assignParam(destType, srcType, paramIndex, diag, constraints, flags, recursionCount) {
         // Handle the special case where the dest type is a synthesized
@@ -17839,7 +17843,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         });
         if (srcTupleTypes.length !== 1 || !(0, types_1.isTypeVarTuple)(srcTupleTypes[0].type)) {
-            const srcPositionalsType = makeTupleObject(srcTupleTypes, /* isUnpackedTuple */ true);
+            const srcPositionalsType = makeTupleObject(srcTupleTypes, /* isUnpacked */ true);
             // Snip out the portion of the source positionals that map to the variadic
             // dest parameter and replace it with a single parameter that is typed as a
             // tuple containing the individual types of the replaced parameters.
@@ -18075,10 +18079,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             let destArgsType = destParamDetails.params[destParamDetails.argsIndex].type;
             let srcArgsType = srcParamDetails.params[srcParamDetails.argsIndex].type;
             if (!(0, types_1.isUnpacked)(destArgsType)) {
-                destArgsType = makeTupleObject([{ type: destArgsType, isUnbounded: true }], /* isUnpackedTuple */ true);
+                destArgsType = makeTupleObject([{ type: destArgsType, isUnbounded: true }], /* isUnpacked */ true);
             }
             if (!(0, types_1.isUnpacked)(srcArgsType)) {
-                srcArgsType = makeTupleObject([{ type: srcArgsType, isUnbounded: true }], /* isUnpackedTuple */ true);
+                srcArgsType = makeTupleObject([{ type: srcArgsType, isUnbounded: true }], /* isUnpacked */ true);
             }
             if (!assignParam(destArgsType, srcArgsType, destParamDetails.params[destParamDetails.argsIndex].index, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                 canAssign = false;