Incorrectly narrows `type` from signature annotation to `Never`

[RolandSaur]

Bug Report

When taking the parameter type from the signature, mypy incorrectly thinks that the annotation of type <class 'type'> is the actual type of the variable.

To Reproduce

In the following example, process_signature extracts the type of input from the signature of a function and then tries to match it to int or float. However the type of input_type is <class 'type'> not int or float. Therefore, when the code is run assert_never is reached.

from typing import Callable, assert_never, reveal_type
from inspect import signature


def takes_int(x: int) -> None:
    print(f"{x} is a int")

def process_signature(
        func: Callable[[int], None] | Callable[[float], None]
) -> None:
    input_type = signature(func).parameters['x'].annotation
    reveal_type(input_type)  # Runtime type is 'type' => should reach `case _:`
    match input_type:
        case int():
            print("This is an int")
        case float():
            print("This is a float")
        case _:
            assert_never(input_type)  # this is reached during runtime


process_signature(takes_int)

Expected Behavior

mypy to complain that input to assert_never is <class 'type'> but expected Never.

Actual Behavior

mypy does not complain.

Your Environment

• Mypy version used: 1.19.1
• Mypy command-line flags: None
• Mypy configuration options from mypy.ini (and other config files): None
• Python version used: 3.13.7

[sterliakov]

This is just

from typing import Any, assert_never

def check(x: Any) -> None:
    assert_never(x)

and it's an interesting problem: we probably want to reject assert_never(Any), but Any should not produce new errors when it replaces some valid type, and in this case x: Never would be such a valid type.

Furthermore, we probably want current behavior in more complex cases where Any comes from inability to denote or figure out the type, like your inspect example - there's nothing more precise than Any, and it can still be Never - I'm not sure what the signal-to-noise ratio will be if we change this behavior. Any is the only type (other than Never itself) assignable to Never, and that's intentional.

[Vaishnavi-Iyer67]

Thanks for the explanation. I understand this is a limitation of Any when using runtime reflection like inspect.signature, and that assert_never(Any) is intentionally allowed. This makes sense to me now.