False postives when decorating functions with signature that uses ParamSpec within a decoarator

[PIG208]

Bug Report

When using a decorator on the decorated function within the definition of another decorator, mypy reports false positives.

To Reproduce

from typing import Callable, TypeVar
from typing_extensions import ParamSpec, Concatenate

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


def identity(func: Callable[P, T]) -> Callable[P, T]:
    def _wrapped(*args: P.args, **kwargs: P.kwargs) -> T:
        return func(*args, **kwargs)

    return _wrapped


def int_identity(func: Callable[Concatenate[int, P], T]) -> Callable[Concatenate[int, P], T]:
    # identify should preserve the signature of _wrapped
    # error: Argument 1 to "identity" has incompatible type "Callable[[Arg(int, 'number'), **P], T]"; expected "Callable[[Arg(int, 'number'), **P], T]"
    @identity
    def _wrapped(number: int, *args: P.args, **kwargs: P.kwargs) -> T:
        return func(number, *args, **kwargs)

    return _wrapped

Expected Behavior

The code should pass type-check with no errors.

Actual Behavior

Got error:
error: Argument 1 to "identity" has incompatible type "Callable[[Arg(int, 'number'), **P], T]"; expected "Callable[[Arg(int, 'number'), **P], T]"

Your Environment

• Mypy version used: 0.960
• Mypy command-line flags: --strict
• Python version used: Python 3.8.10
• Operating system and version: WSL2 - Ubuntu 20.04

[bbatliner]

I think #12806 is a duplicate of this. And I have an example of my own to contribute:

from typing import ParamSpec, Callable, TypeVar
from functools import lru_cache, _lru_cache_wrapper

P = ParamSpec("P")
R = TypeVar("R")


def memoize(f: Callable[P, R]) -> "_lru_cache_wrapper[R]":
    return lru_cache(None)(f)


def function(f: Callable[P, R]) -> None:
    # error: Argument 1 to "memoize" has incompatible type "Callable[[Arg(int, 'a'), **P], None]"; expected "Callable[[Arg(int, 'a'), **P], None]"
    @memoize
    def inner_function(a: int, *args: P.args, **kwargs: P.kwargs) -> None:
        ...
    ...

The "incompatible types" are stringified exactly the same.