Fixed bug related to function type compatibility when the dest type contains an unpacked tuple followed by one or more positional-only parameters as in Callable[[*Ts, int], None]. This addresses #6724. (#6751)

Author: erictraut

packages/pyright-internal/src/analyzer/typeEvaluator.ts

@@ -24266,14 +24266,17 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
 
         const targetIncludesParamSpec = reverseMatching ? !!srcType.details.paramSpec : !!destType.details.paramSpec;
 
-        const destPositionalCount =
-            destParamDetails.argsIndex ?? destParamDetails.firstKeywordOnlyIndex ?? destParamDetails.params.length;
-        const srcPositionalCount =
-            srcParamDetails.argsIndex ?? srcParamDetails.firstKeywordOnlyIndex ?? srcParamDetails.params.length;
+        const destPositionalCount = destParamDetails.firstKeywordOnlyIndex ?? destParamDetails.params.length;
+        const srcPositionalCount = srcParamDetails.firstKeywordOnlyIndex ?? srcParamDetails.params.length;
         const positionalsToMatch = Math.min(destPositionalCount, srcPositionalCount);
 
         // Match positional parameters.
         for (let paramIndex = 0; paramIndex < positionalsToMatch; paramIndex++) {
+            // Skip over the *args parameter since it's handled separately below.
+            if (paramIndex === destParamDetails.argsIndex) {
+                continue;
+            }
+
             const destParam = destParamDetails.params[paramIndex];
             const srcParam = srcParamDetails.params[paramIndex];
 
@@ -24302,7 +24305,11 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
                 }
             }
 
-            if (!!destParam.param.hasDefault && !srcParam.param.hasDefault) {
+            if (
+                !!destParam.param.hasDefault &&
+                !srcParam.param.hasDefault &&
+                paramIndex !== srcParamDetails.argsIndex
+            ) {
                 diag?.createAddendum().addMessage(
                     Localizer.DiagnosticAddendum.functionParamDefaultMissing().format({
                         name: srcParamName,
@@ -24417,6 +24424,10 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
                 // *args parameter type.
                 const srcArgsType = srcParamDetails.params[srcParamDetails.argsIndex].type;
                 for (let paramIndex = srcPositionalCount; paramIndex < destPositionalCount; paramIndex++) {
+                    if (paramIndex === srcParamDetails.argsIndex) {
+                        continue;
+                    }
+
                     const destParamType = destParamDetails.params[paramIndex].type;
                     if (isVariadicTypeVar(destParamType) && !isVariadicTypeVar(srcArgsType)) {
                         diag?.addMessage(Localizer.DiagnosticAddendum.typeVarTupleRequiresKnownLength());
@@ -24451,13 +24462,22 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
                     }
                 }
             } else if (!srcParamDetails.paramSpec) {
-                diag?.addMessage(
-                    Localizer.DiagnosticAddendum.functionTooManyParams().format({
-                        expected: srcPositionalCount,
-                        received: destPositionalCount,
-                    })
-                );
-                canAssign = false;
+                // If the dest contains a *args, remove it from the positional count
+                // because it's OK for zero source args to match it.
+                let adjDestPositionalCount = destPositionalCount;
+                if (destParamDetails.argsIndex !== undefined && destParamDetails.argsIndex < destPositionalCount) {
+                    adjDestPositionalCount--;
+                }
+
+                if (srcPositionalCount < adjDestPositionalCount) {
+                    diag?.addMessage(
+                        Localizer.DiagnosticAddendum.functionTooManyParams().format({
+                            expected: srcPositionalCount,
+                            received: destPositionalCount,
+                        })
+                    );
+                    canAssign = false;
+                }
             }
         }
 

packages/pyright-internal/src/tests/samples/variadicTypeVar27.py

@@ -0,0 +1,53 @@
+# This sample tests the case where a Callable uses an unpacked TypeVarTuple
+# followed by another positional parameter.
+
+from typing import TypeVarTuple, TypeVar, Generic, Callable
+
+T = TypeVar("T")
+Ts = TypeVarTuple("Ts")
+
+
+class A(Generic[*Ts, T]):
+    ...
+
+
+def deco1(x: Callable[[*tuple[*Ts, int]], None]) -> tuple[*Ts]:
+    ...
+
+
+def deco2(x: Callable[[*tuple[*Ts, str]], None]) -> tuple[*Ts]:
+    ...
+
+
+def deco3(x: Callable[[*tuple[str, int]], None]) -> None:
+    ...
+
+
+def deco4(x: Callable[[*Ts, T], None]) -> A[*Ts, T]:
+    return A()
+
+
+def func1(a: str, b: int) -> None:
+    ...
+
+
+def func2(a: str, b: str, c: int) -> None:
+    ...
+
+
+v1 = deco1(func1)
+reveal_type(v1, expected_text="tuple[str]")
+
+v2 = deco1(func2)
+reveal_type(v2, expected_text="tuple[str, str]")
+
+# This should generate an error.
+deco2(func1)
+
+deco3(func1)
+
+v3 = deco4(func1)
+reveal_type(v3, expected_text="A[str, int]")
+
+v4 = deco4(func2)
+reveal_type(v4, expected_text="A[str, str, int]")

packages/pyright-internal/src/tests/typeEvaluator3.test.ts

@@ -1051,7 +1051,7 @@ test('VariadicTypeVar5', () => {
 
     configOptions.defaultPythonVersion = PythonVersion.V3_11;
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['variadicTypeVar5.py'], configOptions);
-    TestUtils.validateResults(analysisResults, 8);
+    TestUtils.validateResults(analysisResults, 9);
 });
 
 test('VariadicTypeVar6', () => {
@@ -1222,6 +1222,14 @@ test('VariadicTypeVar26', () => {
     TestUtils.validateResults(analysisResults, 3);
 });
 
+test('VariadicTypeVar27', () => {
+    const configOptions = new ConfigOptions(Uri.empty());
+
+    configOptions.defaultPythonVersion = PythonVersion.V3_11;
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['variadicTypeVar27.py'], configOptions);
+    TestUtils.validateResults(analysisResults, 1);
+});
+
 test('Match1', () => {
     const configOptions = new ConfigOptions(Uri.empty());