[Backport maintenance/4.0.x] fix: avoid false positive when module-level names match class-level names (#10753)

fix: avoid false positive when module-level names match class-level names (#10723)

Add scope comparision to avoid module-level constants to be incorrectly
classified as variables when a class-level attribute with the same name exists

Closes #10719

(cherry picked from commit e55e830)

Co-authored-by: Joao Faria <joaovitorfaria.dev@gmail.com>

Author: pylint-backport[bot]

doc/whatsnew/fragments/10719.false_positive

@@ -0,0 +1,3 @@
+Fixed false positive for ``invalid-name`` where module-level constants were incorrectly classified as variables when a class-level attribute with the same name exists.
+
+Closes #10719

pylint/checkers/utils.py

@@ -1843,28 +1843,50 @@ def is_sys_guard(node: nodes.If) -> bool:
     return False
 
 
+def _is_node_in_same_scope(
+    candidate: nodes.NodeNG, node_scope: nodes.LocalsDictNodeNG
+) -> bool:
+    if isinstance(candidate, (nodes.ClassDef, nodes.FunctionDef)):
+        return candidate.parent is not None and candidate.parent.scope() is node_scope
+    return candidate.scope() is node_scope
+
+
+def _is_reassigned_relative_to_current(
+    node: nodes.NodeNG, varname: str, before: bool
+) -> bool:
+    """Check if the given variable name is reassigned in the same scope relative to
+    the current node.
+    """
+    node_scope = node.scope()
+    node_lineno = node.lineno
+    if node_lineno is None:
+        return False
+    for a in node_scope.nodes_of_class(
+        (nodes.AssignName, nodes.ClassDef, nodes.FunctionDef)
+    ):
+        if a.name == varname and a.lineno is not None:
+            if before:
+                if a.lineno < node_lineno:
+                    if _is_node_in_same_scope(a, node_scope):
+                        return True
+            elif a.lineno > node_lineno:
+                if _is_node_in_same_scope(a, node_scope):
+                    return True
+    return False
+
+
 def is_reassigned_before_current(node: nodes.NodeNG, varname: str) -> bool:
     """Check if the given variable name is reassigned in the same scope before the
     current node.
     """
-    return any(
-        a.name == varname and a.lineno < node.lineno
-        for a in node.scope().nodes_of_class(
-            (nodes.AssignName, nodes.ClassDef, nodes.FunctionDef)
-        )
-    )
+    return _is_reassigned_relative_to_current(node, varname, before=True)
 
 
 def is_reassigned_after_current(node: nodes.NodeNG, varname: str) -> bool:
     """Check if the given variable name is reassigned in the same scope after the
     current node.
     """
-    return any(
-        a.name == varname and a.lineno > node.lineno
-        for a in node.scope().nodes_of_class(
-            (nodes.AssignName, nodes.ClassDef, nodes.FunctionDef)
-        )
-    )
+    return _is_reassigned_relative_to_current(node, varname, before=False)
 
 
 def is_deleted_after_current(node: nodes.NodeNG, varname: str) -> bool:

tests/checkers/unittest_utils.py

@@ -520,3 +520,105 @@ def test_is_typing_member() -> None:
     )
     assert not utils.is_typing_member(code[0], ("Literal",))
     assert not utils.is_typing_member(code[1], ("Literal",))
+
+
+def test_is_reassigned_after_current_requires_isinstance_check() -> None:
+    tree = astroid.parse(
+        """
+    CONSTANT = 1
+
+    def global_function_assign():
+        global CONSTANT
+        def CONSTANT():
+            pass
+        CONSTANT()
+    """
+    )
+    func = tree.body[1]
+    global_stmt = func.body[0]
+    nested_func = func.body[1]
+
+    assert isinstance(global_stmt, nodes.Global)
+    assert isinstance(nested_func, nodes.FunctionDef)
+
+    node_scope = global_stmt.scope()
+
+    assert nested_func.scope() == nested_func
+    assert nested_func.scope() != node_scope
+
+    assert nested_func.parent.scope() == node_scope
+
+    assert utils.is_reassigned_after_current(global_stmt, "CONSTANT") is True
+
+
+def test_is_reassigned_before_current() -> None:
+    tree = astroid.parse(
+        """
+    x = 1
+    x = 2
+    x = 3
+    """
+    )
+    first_assign = tree.body[0]
+    second_assign = tree.body[1]
+    third_assign = tree.body[2]
+
+    assert isinstance(first_assign, nodes.Assign)
+    assert isinstance(second_assign, nodes.Assign)
+    assert isinstance(third_assign, nodes.Assign)
+
+    third_assign_name = third_assign.targets[0]
+    first_assign_name = first_assign.targets[0]
+
+    assert isinstance(third_assign_name, nodes.AssignName)
+    assert isinstance(first_assign_name, nodes.AssignName)
+
+    assert utils.is_reassigned_before_current(third_assign_name, "x") is True
+    assert utils.is_reassigned_before_current(first_assign_name, "x") is False
+
+
+def test_is_reassigned_after_current_with_assignname() -> None:
+    tree = astroid.parse(
+        """
+    x = 1
+    x = 2
+    x = 3
+    """
+    )
+    first_assign = tree.body[0]
+    second_assign = tree.body[1]
+    third_assign = tree.body[2]
+
+    assert isinstance(first_assign, nodes.Assign)
+    assert isinstance(second_assign, nodes.Assign)
+    assert isinstance(third_assign, nodes.Assign)
+
+    first_assign_name = first_assign.targets[0]
+    third_assign_name = third_assign.targets[0]
+
+    assert isinstance(first_assign_name, nodes.AssignName)
+    assert isinstance(third_assign_name, nodes.AssignName)
+
+    assert utils.is_reassigned_after_current(first_assign_name, "x") is True
+    assert utils.is_reassigned_after_current(third_assign_name, "x") is False
+
+
+def test_is_reassigned_with_node_no_lineno() -> None:
+    tree = astroid.parse(
+        """
+    x = 1
+    x = 2
+    """
+    )
+    first_assign = tree.body[0]
+    first_assign_name = first_assign.targets[0]
+
+    assert isinstance(first_assign_name, nodes.AssignName)
+    original_lineno = first_assign_name.lineno
+    first_assign_name.lineno = None
+
+    try:
+        assert utils.is_reassigned_after_current(first_assign_name, "x") is False
+        assert utils.is_reassigned_before_current(first_assign_name, "x") is False
+    finally:
+        first_assign_name.lineno = original_lineno

tests/functional/i/invalid/invalid_name/invalid_name_module_level.py

@@ -55,3 +55,15 @@ def A():  # [invalid-name]
 
 from typing import Annotated
 IntWithAnnotation = Annotated[int, "anything"]
+
+
+# Regression test for #10719: module-level constants should not be incorrectly
+# classified as variables when a class-level attribute with the same name exists.
+class Theme:
+    INPUT = ">>> "
+
+
+INPUT = Theme()
+input = Theme()  # pylint: disable=redefined-builtin
+OUTPUT = Theme()
+output = Theme()

tests/functional/n/no/no_dummy_redefined.py

@@ -1,4 +1,5 @@
 """Make sure warnings about redefinitions do not trigger for dummy variables."""
+# pylint: disable=invalid-name
 
 
 _, INTERESTING = 'a=b'.split('=')

tests/functional/n/no/no_dummy_redefined.txt

@@ -1 +1 @@
-redefined-outer-name:11:4:11:9:clobbering:Redefining name 'value' from outer scope (line 6):UNDEFINED
+redefined-outer-name:12:4:12:9:clobbering:Redefining name 'value' from outer scope (line 7):UNDEFINED