Lint unused variable assignment / dead store (false negative `unused-variable`?)

[richardebeling]

(Issue altered after the discussions up to #5838 (comment) to better reflect intention)

Problem description

Pylint will give unused-variable / W0612 when code assigns a variable that is never used, but this message will not appear if there was any usage of the variable in the past. However, in code, I'd consider it a code smell to assign an unused value to a variable, even if the variable was used before. Consider this code:

#! /usr/bin/env python3
# pylint: disable=missing-docstring

def some_func():
    var = 3
    print(var)
    var = 4
    # var is never used again. The last assignment thus could be removed.

In c++ code, clang-tidy would warn about the dead store.

Expected behavior

Initially, I had considered this to be a case for unused-variable. As @jacobtylerwalls pointed out, the variable is technically used, so maybe it should be a different message.

************* Module test
test.py:6:4: W0612: Unused variable 'var' (unused-variable)

-------------------------------------------------------------------
Your code has been rated at 6.67/10 (previous run: 10.00/10, -3.33)

Pylint version

pylint 2.13.0-dev0
astroid 2.9.3
Python 3.9.7 (default, Sep 10 2021, 14:59:43) [GCC 11.2.0]

(installed from main at 6622d10)

[Pierre-Sassoulas]

Thank you for opening the issue after checking on the latest main branch :)

[jacobtylerwalls]

Interesting case to think about. What definition would we rely on for "used", then? var was used in the course of getting the max of itself and 1. What about that is not "use"? 🤔

[Pierre-Sassoulas]

Hmm, I marked as false negative too fast, I think @jacobtylerwalls is right.

[richardebeling]

I was thinking of "unused" as "the value you assign here is never used afterwards", inspired by how clang-tidy would lint it as a dead store in c++ code.

I thought pylint would lint such cases in general, but just learned that it doesn't. In this case, this is not really a bug report. Would it make sense to open a feature request for this?

[DanielNoord]

I think this could be a feature request for the CodeStyle checker. Although obviously impacting performance I think such intermediate assignment are often used for clarity and readability and I don't think we should warn against them outright.

[richardebeling]

I think this could be a feature request for the CodeStyle checker. Although obviously impacting performance I think such intermediate assignment are often used for clarity and readability and I don't think we should warn against them outright.

Just to make sure there's no misunderstanding, let me clarify: My problem is not with immediate reassignment. This is fine because var is used after its last assignment:

def some_func():
    var = some_computation_that_gives_immediate_result()
    var = some_follow_up_computation_that_gives_final_result(var)
    print(var)

My problem is with assignments that are not used:

def some_func():
    var = 3
    print(var)
    var = 4
    # var now goes out of scope, so the last value assigned will never be used.

The code I initially stumbled upon just happened to combine both:

def some_func():
    var = some_computation_that_gives_immediate_result()
    var = some_follow_up_computation_that_gives_final_result(var)
    # again, value stored to var is unused

I initially thought pylint would already lint this, and the self-reassignment was a special case, but turns out it is not. I changed the issue title and text to better reflect my actual intention (hope that's fine with the maintainers).