redefinition-new does not apply type narrowing on cast-like function calls

[DerBiasto]

Bug Report

I have a function to which I am passing both a type and a value that the function converts to be of that type.

(In the example, the function simply calls cast, in my actual use case it does some actual conversions of course.)

mypy correctly determines the type of the return, but assigning this return to the variable does not narrow the type of the variable, when using --allow-redefinition-new. This does not happen with --allow-redefinition-old

For other function calls that convert the input, this works perfectly fine.

(A clear and concise description of what the bug is.)

To Reproduce

from collections.abc import Collection
from typing import Any, cast, reveal_type

def convert[T](type_: type[T], x: Any) -> T:
    return cast(T, x)

def to_set[T](x: Collection[T]) -> set[T]:
    return set(x)

def foo(x: Collection[int]) -> None:
    reveal_type(x)  # Collection[int]
    reveal_type(convert(set[int], x))  # set[int]
    x = convert(set[int], x)
    reveal_type(x)  # old: set[int], new: Collection[int]

def bar(x: Collection[int]) -> None:
    reveal_type(x)  # Collection[int]
    reveal_type(cast(set[int], x))  # set[int]
    x = cast(set[int], x)
    reveal_type(x)  # set[int]

def baz(x: Collection[int]) -> None:
    reveal_type(x)  # Collection[int]
    reveal_type(set(x))  # set[int]
    x = set(x)
    reveal_type(x)  # set[int]

def brr(x: Collection[int]) -> None:
    reveal_type(x)  # Collection[int]
    reveal_type(to_set(x))  # set[int]
    x = to_set(x)
    reveal_type(x)  # set[int]

Playground 1.20.2 old redefinitions

Playground 1.20.2 new redefinitions

Playground 2.1.0 new redefinitions

(The playground does not support --allow-redefinition-old so you cannot use the old variant with 2.0+)

Expected Behavior

After x = convert(set[int], x) the type of x should be narrowed to set[int].

Actual Behavior

It works with the old, but not the new --allow-redefinition.

Your Environment

I encountered this when upgrading to mypy==2.0.0, when the default behavior of --allow-redefinition changed from old to new, but this also happens on mypy==1.20.2 and mypy==2.1.0.

[DerBiasto]

I found another similar thing with comprehensions:

def foo(x: Collection[int | None]) -> None:
    reveal_type(x)  # Collection[int | None]
    reveal_type({y for y in x if y})  # set[int]
    x = {y for y in x if y}
    reveal_type(x)  # old: set[int], new: set[int | None]

The narrowing from set to collection works, but the inner type isn't narrowed with new redefinitions.

[DerBiasto]

Another variant:

from typing import Any

type MyAlias = dict[str, Any]

def foo(data: list[dict[str, Any]]) -> None:
    _id = 1
    for datum in data:
        reveal_type(datum.get("id", _id))  # Any
        _id = datum.get("id", _id)
        reveal_type(_id)  # Any

def bar(data: list[MyAlias]) -> None:
    _id = 1
    for datum in data:
        reveal_type(datum.get("id", _id))  # new: Any | None
        _id = datum.get("id", _id)
        reveal_type(_id)  # old: Any, new: Any | None
        
def foo2(datum: dict[str, Any]) -> None:
    _id = 1
    reveal_type(datum.get("id", _id))  # Any
    _id = datum.get("id", _id)
    reveal_type(_id)  # Any

def bar2(datum: MyAlias) -> None:
    _id = 1
    reveal_type(datum.get("id", _id))  # Any
    _id = datum.get("id", _id)
    reveal_type(_id)  # Any

https://mypy-play.net/?mypy=1.20.2&python=3.14&flags=allow-redefinition-new%2Clocal-partial-types&gist=bd413d054a355435a99dd2759ccaedcb

https://mypy-play.net/?mypy=1.20.2&python=3.14&flags=allow-redefinition%2Clocal-partial-types&gist=bd413d054a355435a99dd2759ccaedcb