Added support for ... in the last type argument of Concatenate. After much discussion (see python/cpython#30969), it has been decided to support this even though a strict reading of PEP 612 seems to exclude it. This addresses #5715.

Author: msfterictraut

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

@@ -6531,6 +6531,9 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
 
                                 if (isParamSpec(typeArg)) {
                                     functionType.details.paramSpec = typeArg;
+                                } else if (isEllipsisType(typeArg)) {
+                                    FunctionType.addDefaultParameters(functionType);
+                                    functionType.details.flags |= FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck;
                                 }
                             } else {
                                 FunctionType.addParameter(functionType, {
@@ -14078,6 +14081,9 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
 
                                 if (isParamSpec(typeArg)) {
                                     functionType.details.paramSpec = typeArg;
+                                } else if (isEllipsisType(typeArg)) {
+                                    FunctionType.addDefaultParameters(functionType);
+                                    functionType.details.flags |= FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck;
                                 }
                             } else {
                                 FunctionType.addParameter(functionType, {
@@ -14606,7 +14612,7 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
         } else {
             typeArgs.forEach((typeArg, index) => {
                 if (index === typeArgs.length - 1) {
-                    if (!isParamSpec(typeArg.type)) {
+                    if (!isParamSpec(typeArg.type) && !isEllipsisType(typeArg.type)) {
                         addError(Localizer.Diagnostic.concatenateParamSpecMissing(), typeArg.node);
                     }
                 } else {
@@ -14673,7 +14679,9 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
                 typeArgs.forEach((typeArg, index) => {
                     if (isEllipsisType(typeArg.type)) {
                         if (!isTupleTypeParam) {
-                            addError(Localizer.Diagnostic.ellipsisContext(), typeArg.node);
+                            if (!allowParamSpec) {
+                                addError(Localizer.Diagnostic.ellipsisContext(), typeArg.node);
+                            }
                         } else if (typeArgs!.length !== 2 || index !== 1) {
                             addError(Localizer.Diagnostic.ellipsisSecondArg(), typeArg.node);
                         } else {
@@ -19136,6 +19144,10 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
                                 if (index === concatTypeArgs.length - 1) {
                                     if (isParamSpec(typeArg)) {
                                         functionType.details.paramSpec = typeArg;
+                                    } else if (isEllipsisType(typeArg)) {
+                                        FunctionType.addDefaultParameters(functionType);
+                                        functionType.details.flags |=
+                                            FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck;
                                     }
                                 } else {
                                     FunctionType.addParameter(functionType, {

packages/pyright-internal/src/localization/package.nls.en-us.json

@@ -67,7 +67,7 @@
         "comparisonAlwaysTrue": "Condition will always evaluate to True since the types \"{leftType}\" and \"{rightType}\" have no overlap",
         "comprehensionInDict": "Comprehension cannot be used with other dictionary entries",
         "comprehensionInSet": "Comprehension cannot be used with other set entries",
-        "concatenateParamSpecMissing": "Last type argument for \"Concatenate\" must be a ParamSpec",
+        "concatenateParamSpecMissing": "Last type argument for \"Concatenate\" must be a ParamSpec or \"...\"",
         "concatenateTypeArgsMissing": "\"Concatenate\" requires at least two type arguments",
         "conditionalOperandInvalid": "Invalid conditional operand of type \"{type}\"",
         "constantRedefinition": "\"{name}\" is constant (because it is uppercase) and cannot be redefined",

packages/pyright-internal/src/tests/samples/ellipsis1.pyi

@@ -8,8 +8,7 @@ _T1 = TypeVar("_T1")
 class MyGenericClass1(Generic[_T1]):
     pass
 
-# This should generate two errors because ... cannot be used
-# in a Generic list and it's not a type variable.
+# This should generate an error because ... is not a type variable.
 class MyGenericClass2(Generic[_T1, ...]):
     pass
 

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

@@ -0,0 +1,40 @@
+# This sample tests support for Concatenate with a ... type argument.
+
+from typing import Callable, Concatenate
+
+TA1 = Callable[Concatenate[int, ...], None]
+
+
+def func1(cb: Callable[Concatenate[int, str, ...], None]):
+    ...
+
+
+def func2(cb: TA1):
+    ...
+
+
+def cb1(x: int, y: str, z: str) -> None:
+    ...
+
+
+func1(cb1)
+func2(cb1)
+
+
+def cb2(x: int, y: str, *args: int, **kwargs: str) -> None:
+    ...
+
+
+func1(cb2)
+func2(cb2)
+
+
+def cb3(x: str, y: str) -> None:
+    ...
+
+
+# This should generate an error.
+func1(cb3)
+
+# This should generate an error.
+func2(cb3)

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

@@ -27,7 +27,7 @@ test('Module2', () => {
 test('Ellipsis1', () => {
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['ellipsis1.pyi']);
 
-    TestUtils.validateResults(analysisResults, 11);
+    TestUtils.validateResults(analysisResults, 10);
 });
 
 test('Generator1', () => {

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

@@ -1048,6 +1048,11 @@ test('ParamSpec45', () => {
     TestUtils.validateResults(results, 0);
 });
 
+test('ParamSpec46', () => {
+    const results = TestUtils.typeAnalyzeSampleFiles(['paramSpec46.py']);
+    TestUtils.validateResults(results, 2);
+});
+
 test('ClassVar1', () => {
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['classVar1.py']);