unnecessary-lambda false positive (expression variable reassigned)

[belm0]

Bug description

pylint unnecessary-lambda doesn't seem to understand that reassignment of a variable containing a class instance affects bound methods can necessitate use of a lambda:

def test_foo():
    foo = {'hello': 42}
    some_mock = unittest.mock.Mock()
    some_mock.bar.side_effect = lambda k: foo.get(k)  # warning: unnecessary-lambda
    assert some_mock.bar('hello') == 42
    foo = {'goodbye': 0}
    assert some_mock.bar('goodbye') == 0

Configuration

No response

Command used

pylint test.py

Pylint output

test.py:50:32: W0108: Lambda may not be necessary (unnecessary-lambda)

Expected behavior

no warning, since the variable holding the class instance (in this case, a dict) used in the lambda expression is reassigned locally

Pylint version

pylint 2.15.5
astroid 2.12.12
Python 3.8.12 (default, Sep 23 2021, 08:42:37)
[Clang 12.0.0 (clang-1200.0.32.29)]

OS / Environment

No response

Additional dependencies

No response

[nickdrozd]

This is an interesting one. Actually it has nothing to with class attributes. Instead, the issue is when variables are looked up.

I suppose Pylint is suggesting that lambda x: foo.get(x) should be replaced with just foo.get. But with the lambda expression, the value of foo is not determined until the lambda expression is called, whereas with foo.get the value of foo is determined immediately. By waiting until call time, the lambda might get different values of foo, or no value at all. Consider:

f = lambda x: foo.get(x)  # false positive unnecessary-lambda

# an object is created and given the name 'foo'
foo = {1: 2}
assert f(1) == 2

# a new object is created and given the name 'foo'; first object is lost
foo = {1: 3}
assert f(1) == 3

# the name 'foo' is deleted; second object is lost
del foo

assert f(1) == 3  # NameError: name 'foo' is not defined

Changing the lambda expression to a full function definition does not change this behavior.

The current unnecessary-lambda warning is an error, since it suggests making a bad change. But I wonder if Pylint should issue some kind of warning for these situations where a function refers to a variable outside of its definition and then that variable is reassigned. This behavior is a little unnerving, and I'm sure somebody has encountered problems because of it.

[belm0]

The message for unnecessary-lambda is the tentative, "Lambda may not be necessary", but generally I'd like pylint to try harder to avoid false positives, else remove the check.

In this case, I wonder if it would be hard for the checker to suppress the error if any variable referenced in the expression is reassigned.