Regression: ParamSpecs are converted to '...' when used in returned Callable

[GugelRobin]

Describe the bug
See code.

Pyright >1.1.309 starts having the bug

Pylance has the problem as well.

Code or Screenshots

from typing import TypeVar, ParamSpec

T = TypeVar("T")
P = ParamSpec("P")

def foo() -> Callable[[Callable[P, T]], Callable[P, T]]:
    ...

def bar(x: int) -> str:
    ...

reveal_type(foo()(bar)) 
# pyright >  1.1.310 outputs: Type of "foo()(bar)" is "(...) -> str"
# pyright <= 1.1.309 outputs: Type of "foo()(bar)" is "(x: int) -> str"

[erictraut]

This is an ambiguous part of the typing spec. In a strict reading of PEP 484, both P and T are scoped to foo and must be solved in the context of a call to foo. However, pyright and mypy provide some special-case logic when a type variable is used only within a return callable where they assume that the type variable is scoped to the callable rather than the function. It looks like I broke that special casing for ParamSpec but not for regular type variables. I'll investigate.

[erictraut]

This will be fixed in the next release.

[erictraut]

This is addressed in pyright 1.1.314, which I just published. It will also be included in this week's Pylance prerelease build.

[rslinckx]

@erictraut I have the following test case which seems to also have ceased working after 1.1.309, and seems related:

from __future__ import annotations

from dataclasses import dataclass
from typing import Callable, Generic, ParamSpec

P = ParamSpec("P")


@dataclass
class TaskDeclaration(Generic[P]):
    func: Callable[P, None]

    def enqueue(self, something: str, *args: P.args, **kwargs: P.kwargs) -> None:
        pass


def task() -> Callable[[Callable[P, None]], TaskDeclaration[P]]:
    def decorator(func: Callable[P, None]) -> TaskDeclaration[P]:
        return TaskDeclaration(func)

    return decorator


@task()
def test(a: int) -> None:
    pass


test.enqueue("something") # Should have been test.enqueue("something", 3) to be valid

Output with <=1.1.309: test.py:29:1 - error: Argument missing for parameter "a" (reportGeneralTypeIssues)
Output with >1.1.309(including 314): 0 errors, 0 warnings, 0 informations

[GugelRobin]

@erictraut @rslinckx
The problem seems to be that the ParamSpec is still bound in the returned callable when the ParamSpec is used in a generic class (while a TypeVar still stays unbound).
Strange enough, if P is bound just by generic classes (and not a callable) it still works.
I've produced a minimal example for you (pyright 1.1.314)

from typing import Callable, Generic, ParamSpec

P = ParamSpec("P")
T = TypeVar("T")

class Foo(Generic[P, T]):
    ...

class Bar(Generic[P, T]):
    ...

def fail() -> Callable[[Callable[P, T]], Foo[P, T]]:
    ...

def success() -> Callable[[Callable[P, T]], Callable[P, T]]:
    ...

def success2() -> Callable[[Foo[P, T]], Bar[P, T]]:
    ...

reveal_type(fail())
# Type of "fail()" is "((**P@fail) -> T@fail) -> Foo[(...), T@fail]"
reveal_type(success())
# Type of "success()" is "((**P@success) -> T@success) -> ((**P@success) -> T@success)"
reveal_type(success2())
# Type of "success2()" is "(Foo[P@success2, T@success2]) -> Bar[P@success2, T@success2]"

[erictraut]

Ah, my bad. I missed a small detail that caused my previous fix not to work with a class parameterized with a ParamSpec, as with TaskDeclaration in your example above. I've fixed the issue and further augmented the pyright unit tests to cover this case.

[erictraut]

This is included in pyright 1.1.315, which I just published. It will also be included in this week's insiders release of pylance.