Inconsistent type analysis in lambdas for redundant-expr

[sk-]

Bug Report
I found a weird issue related to redundant-expr that only happens when the code is defined as a lambda. The same code works fine when defined inside a regular function.

To Reproduce

from typing import Any

import pandas as pd

lambda val: {} if pd.isna(val) else val


def func(val: Any) -> Any:
    return {} if pd.isna(val) else val

Expected Behavior
None of the pd.isna calls are flagged as redundant
Actual Behavior

test_mypy.py:5: error: If condition is always false  [redundant-expr]
Found 1 error in 1 file (checked 1 source file)

Your Environment

• Mypy version used: mypy 1.15.0 (compiled: yes)
• Mypy command-line flags: mypy --enable-error-code redundant-expr test_mypy.py
• Mypy configuration options from mypy.ini (and other config files):
• Python version used: 3.12.9

[brianschubert]

Minimized reproducer without pandas:

from typing import Any, Never, overload

class Foo:
    def __bool__(self) -> Never: assert False

@overload
def bar(x: Foo) -> Foo: ...
@overload
def bar(x: str) -> str: ...
def bar(x: str | Foo) -> str | Foo: return x


def func(val: Any) -> Any:
    return {} if bar(val) else val   # OK

lambda val: {} if bar(val) else val  # E: If condition is always false  [redundant-expr]

From what I can tell, this is what's going on:

• In the function case, bar(val) gets resolved to the type Any. Since Any can be both truthy and falsy, both branches are reachable. All is well.
• In the lambda case, bar(val) gets resolved to the type Foo (curiously, not Foo | str). When mypy tries to truthy-narrow Foo, it finds the __bool__ method with a return type of Never. Since Never can't be truthy, it decides that the truthy-branch is unreachable. The same thing happens when checking the falsey branch.

[A5rocks]

Yeah; reproducing that with reveal_type:

from typing import Any, Never, overload

class Foo:
    def __bool__(self) -> Never: assert False

@overload
def bar(x: Foo) -> Foo: ...
@overload
def bar(x: str) -> str: ...
def bar(x: str | Foo) -> str | Foo: return x


def func(val: Any) -> Any:
    return {} if bar(val) else val   # OK

                               #  v N: Revealed type is "Any"
lambda val: {} if reveal_type(bar(reveal_type(val))) else val  # E: If condition is always false  [redundant-expr]
                # ^ N: Revealed type is "__main__.Foo"
z: Any
reveal_type(bar(z))  # N: Revealed type is "Any"