Collect the iterable's attribute paths with a scope-aware visitor

Addresses the two review points.

Walking node.iter with ast.walk ignored lexical scope, which the name
side of the check does not: B020NameFinder skips names bound by a
comprehension or a lambda. So in

    for obj.value in [obj.value for obj in objects]:

the comprehension-local obj.value was matched against the loop target
and the loop was reported. B020AttributeFinder now collects the paths,
inheriting those exclusions, and drops paths rooted in a lambda
argument the same way the base class drops the argument names.

The eval file's 'Should emit' header is refreshed. It was stale by more
than the new line: line 32 was missing from it as well.

Author: Eljees

bugbear.py

@@ -975,7 +975,7 @@ def check_for_b019(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> None:
                 return
 
     def check_for_b020(self, node: ast.For) -> None:
-        iterset = B020NameFinder()
+        iterset = B020AttributeFinder()
         iterset.visit(node.iter)
         iterset_names = set(iterset.names)
 
@@ -984,11 +984,7 @@ def check_for_b020(self, node: ast.For) -> None:
         # attribute of the same object. Compare the whole dotted path instead.
         candidates: dict[str, ast.expr] = dict(_dotted_targets(node.target))
         if candidates:
-            for sub in ast.walk(node.iter):
-                if isinstance(sub, ast.Attribute):
-                    path = _dotted_name(sub)
-                    if path is not None:
-                        iterset_names.add(path)
+            iterset_names |= iterset.paths
 
         # a name that only ever appears in load context is the *base* of an
         # attribute or subscript target, not something the loop rebinds
@@ -2272,6 +2268,31 @@ def visit_Lambda(self, node) -> None:
             self.names.pop(lambda_arg.arg, None)
 
 
+@attr.s
+class B020AttributeFinder(B020NameFinder):
+    """Dotted attribute paths, under the scope rules B020NameFinder uses for names.
+
+    Collecting the paths with a plain `ast.walk` would ignore lexical scope: in
+    `for obj.value in [obj.value for obj in objects]` the two `obj` bindings are
+    different objects, and the comprehension-local one must not be matched
+    against the loop target.
+    """
+
+    paths: set[str] = attr.ib(factory=set)
+
+    def visit_Attribute(self, node: ast.Attribute) -> None:
+        path = _dotted_name(node)
+        if path is not None:
+            self.paths.add(path)
+        self.generic_visit(node)
+
+    def visit_Lambda(self, node: ast.Lambda) -> None:
+        super().visit_Lambda(node)
+        for lambda_arg in node.args.args:
+            prefix = f"{lambda_arg.arg}."
+            self.paths = {path for path in self.paths if not path.startswith(prefix)}
+
+
 B005_METHODS = {"lstrip", "rstrip", "strip"}
 
 # Note: these are also used by B039

tests/eval_files/b020.py

@@ -1,6 +1,6 @@
 """
 Should emit:
-B020 - on lines 8, 21, and 36
+B020 - on lines 8, 21, 32, 36, 58, and 75
 """
 
 items = [1, 2, 3]
@@ -57,3 +57,20 @@ def ok_plain_attribute(self):
     def still_an_error(self):
         for self.test_suite in self.test_suite:  # B020: 12, "self.test_suite"
             print(self.test_suite)
+
+# the `obj` a comprehension binds is not the `obj` the loop rebinds
+def ok_comprehension_scope(obj, objects):
+    for obj.value in [obj.value for obj in objects]:
+        print(obj.value)
+
+
+# nor is the `obj` a lambda binds
+def ok_lambda_scope(obj, objects):
+    for obj.value in map(lambda obj: obj.value, objects):
+        print(obj.value)
+
+
+# the same path on both sides is still an error
+def still_an_error_at_module_level(obj):
+    for obj.value in obj.value:  # B020: 8, "obj.value"
+        print(obj.value)