Fix FURB148 false positive when loop variable is used after loop (#370)

When a for-loop variable from enumerate() is used after the loop body
(e.g., `print(index)` after the for loop), FURB148 incorrectly warns
that the variable is unused. This happens because the check only
examines the loop body, not subsequent statements in the enclosing
block.

The fix registers the check for Block/MypyFile nodes (in addition to
GeneratorExpr/DictionaryComprehension), allowing it to examine
statements following the for loop. When checking for unused variables,
it now considers both the loop body and subsequent statements, stopping
at any reassignment of the variable.

Fixes #339.

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: worksbyfriday

refurb/checks/builtin/no_ignored_enumerate.py

@@ -1,17 +1,23 @@
 from dataclasses import dataclass
 
 from mypy.nodes import (
+    AssignmentStmt,
+    Block,
     CallExpr,
     DictionaryComprehension,
     Expression,
     ForStmt,
     GeneratorExpr,
+    MypyFile,
     NameExpr,
     Node,
+    Statement,
     TupleExpr,
 )
 
 from refurb.checks.common import (
+    ReadCountVisitor,
+    check_block_like,
     check_for_loop_like,
     get_mypy_type,
     is_name_unused_in_contexts,
@@ -57,11 +63,81 @@ class ErrorInfo(Error):
     categories = ("builtin",)
 
 
+def _assigns_name(stmt: Statement, name: NameExpr) -> bool:
+    """Check if a statement assigns to the given name."""
+    match stmt:
+        case ForStmt(index=index):
+            return _node_contains_name(index, name)
+        case AssignmentStmt(lvalues=lvalues):
+            return any(_node_contains_name(lv, name) for lv in lvalues)
+    return False
+
+
+def _node_contains_name(node: Node, name: NameExpr) -> bool:
+    """Check if a node contains a NameExpr with the same fullname."""
+    visitor = ReadCountVisitor(name)
+    visitor.accept(node)
+    return bool(visitor.was_read)
+
+
+def _is_name_read_after_loop(name: NameExpr, remaining_stmts: list[Statement]) -> bool:
+    """Check if name is read in statements after the loop, stopping at reassignment."""
+    for stmt in remaining_stmts:
+        if _assigns_name(stmt, name):
+            # Name is reassigned — reads after this point don't count
+            # as uses of the loop variable. But check the RHS first.
+            rhs: Expression | None = None
+            if isinstance(stmt, AssignmentStmt):
+                rhs = stmt.rvalue
+            elif isinstance(stmt, ForStmt):
+                rhs = stmt.expr
+
+            if rhs is not None:
+                visitor = ReadCountVisitor(name)
+                visitor.accept(rhs)
+                if visitor.was_read:
+                    return True
+
+            return False
+
+        # Check if name is read in this statement
+        visitor = ReadCountVisitor(name)
+        visitor.accept(stmt)
+        if visitor.was_read:
+            return True
+
+    return False
+
+
 def check(
-    node: ForStmt | GeneratorExpr | DictionaryComprehension,
+    node: Block | MypyFile | GeneratorExpr | DictionaryComprehension,
     errors: list[Error],
 ) -> None:
-    check_for_loop_like(check_enumerate_call, node, errors)
+    match node:
+        case GeneratorExpr() | DictionaryComprehension():
+            check_for_loop_like(check_enumerate_call, node, errors)
+
+        case Block() | MypyFile():
+            check_block_like(check_stmts_for_enumerate, node, errors)
+
+
+def check_stmts_for_enumerate(stmts: list[Statement], errors: list[Error]) -> None:
+    for i, stmt in enumerate(stmts):
+        if not isinstance(stmt, ForStmt):
+            continue
+
+        match stmt.index, stmt.expr:
+            case (
+                TupleExpr(items=[NameExpr() as index, NameExpr() as value]),
+                CallExpr(
+                    callee=NameExpr(fullname="builtins.enumerate"),
+                    args=[enumerate_arg],
+                ),
+            ) if is_subclass(get_mypy_type(enumerate_arg), "typing.Sequence"):
+                remaining = stmts[i + 1 :]
+                check_unused_index_or_value_in_block(
+                    index, value, stmt.body, remaining, errors, enumerate_arg
+                )
 
 
 def check_enumerate_call(
@@ -94,3 +170,23 @@ def check_unused_index_or_value(
         msg = f"Value is unused, use `for {stringify(index)} in range(len({stringify(enumerate_arg)}))` instead"  # noqa: E501
 
         errors.append(ErrorInfo.from_node(value, msg))
+
+
+def check_unused_index_or_value_in_block(  # noqa: PLR0913, PLR0917
+    index: NameExpr,
+    value: NameExpr,
+    body: Node,
+    remaining_stmts: list[Statement],
+    errors: list[Error],
+    enumerate_arg: Expression,
+) -> None:
+    index_unused_in_body = is_name_unused_in_contexts(index, [body])
+    value_unused_in_body = is_name_unused_in_contexts(value, [body])
+
+    if index_unused_in_body and not _is_name_read_after_loop(index, remaining_stmts):
+        msg = f"Index is unused, use `for {stringify(value)} in {stringify(enumerate_arg)}` instead"  # noqa: E501
+        errors.append(ErrorInfo.from_node(index, msg))
+
+    if value_unused_in_body and not _is_name_read_after_loop(value, remaining_stmts):
+        msg = f"Value is unused, use `for {stringify(index)} in range(len({stringify(enumerate_arg)}))` instead"  # noqa: E501
+        errors.append(ErrorInfo.from_node(value, msg))

test/data/err_148.py

@@ -50,3 +50,29 @@ class C:
 
 _ = ((index, _) for index, _ in enumerate(nums))
 _ = ((_, num) for _, num in enumerate(nums))
+
+# index used after loop (GH-339)
+for index, value in enumerate(nums):
+    print(value)
+print(f"Last index {index}")
+
+# value used after loop
+for index, value in enumerate(nums):
+    print(index)
+_ = value
+
+# index reassigned after loop using its own value (should not warn)
+for index, value in enumerate(nums):
+    print(value)
+index = index + 1
+
+# value reassigned after loop (not reading it, should warn on index)
+for index, value in enumerate(nums):
+    print(value)
+value = "overwritten"
+
+# index reassigned by a for-loop that also reads it in the iterable (should not warn)
+for index, value in enumerate(nums):
+    print(value)
+for index in range(index):
+    pass

test/data/err_148.txt

@@ -13,3 +13,4 @@ test/data/err_148.py:28:5 [FURB148]: Index is unused, use `for num in nums` inst
 test/data/err_148.py:28:12 [FURB148]: Value is unused, use `for index in range(len(nums))` instead
 test/data/err_148.py:34:5 [FURB148]: Index is unused, use `for num in C().l` instead
 test/data/err_148.py:34:12 [FURB148]: Value is unused, use `for index in range(len(C().l))` instead
+test/data/err_148.py:70:5 [FURB148]: Index is unused, use `for value in nums` instead