Don't track names, just line numbers

Author: amyreese

dowsing/setuptools/setup_py_parsing.py

@@ -189,7 +189,7 @@ def visit_Call(self, node: cst.Call) -> Optional[bool]:
     PRETEND_ARGV = ["setup.py", "bdist_wheel"]
 
     def evaluate_in_scope(
-        self, item: cst.CSTNode, scope: Any, target_name: str = "", target_line: int = 0
+        self, item: cst.CSTNode, scope: Any, target_line: int = 0
     ) -> Any:
         qnames = self.get_metadata(QualifiedNameProvider, item)
 
@@ -211,20 +211,26 @@ def evaluate_in_scope(
                 reverse=True,
             )
             # Walk assignments from bottom to top, evaluating them recursively.
-            # When recursing, only look at assignments above the "target line".
             for lineno, node in assignment_nodes:
+
+                # When recursing, only look at assignments above the "target line".
+                if target_line and lineno >= target_line:
+                    continue
+
                 # Assign(
                 #   targets=[AssignTarget(target=Name(value="v"))],
                 #   value=SimpleString(value="'x'"),
                 # )
+                #
+                # AugAssign(
+                #   target=Name(value="v"),
+                #   operator=AddAssign(...),
+                #   value=SimpleString(value="'x'"),
+                # )
+                #
                 # TODO or an import...
                 # TODO builtins have BuiltinAssignment
 
-                # we have recursed, likey due to `x = x + y` assignment or similar
-                # self-referential evaluation, and can't
-                if target_name and target_name == name and lineno >= target_line:
-                    continue
-
                 try:
                     if node:
                         parent = self.get_metadata(ParentNodeProvider, node)
@@ -245,9 +251,9 @@ def evaluate_in_scope(
 
                 # This presumes a single assignment
                 if isinstance(gp, cst.Assign) and len(gp.targets) == 1:
-                    result = self.evaluate_in_scope(gp.value, scope, name, lineno)
+                    result = self.evaluate_in_scope(gp.value, scope, lineno)
                 elif isinstance(parent, cst.AugAssign):
-                    result = self.evaluate_in_scope(parent, scope, name, lineno)
+                    result = self.evaluate_in_scope(parent, scope, lineno)
                 else:
                     # too complicated?
                     continue
@@ -265,7 +271,6 @@ def evaluate_in_scope(
                     self.evaluate_in_scope(
                         el.value,
                         self.get_metadata(ScopeProvider, el),
-                        target_name,
                         target_line,
                     )
                 )
@@ -284,12 +289,10 @@ def evaluate_in_scope(
             for arg in item.args:
                 if isinstance(arg.keyword, cst.Name):
                     args[names.index(arg.keyword.value)] = self.evaluate_in_scope(
-                        arg.value, scope, target_name, target_line
+                        arg.value, scope, target_line
                     )
                 else:
-                    args[i] = self.evaluate_in_scope(
-                        arg.value, scope, target_name, target_line
-                    )
+                    args[i] = self.evaluate_in_scope(arg.value, scope, target_line)
                     i += 1
 
             # TODO clear ones that are still default
@@ -303,7 +306,7 @@ def evaluate_in_scope(
             for arg in item.args:
                 if isinstance(arg.keyword, cst.Name):
                     d[arg.keyword.value] = self.evaluate_in_scope(
-                        arg.value, scope, target_name, target_line
+                        arg.value, scope, target_line
                     )
                 # TODO something with **kwargs
             return d
@@ -312,19 +315,19 @@ def evaluate_in_scope(
             for el2 in item.elements:
                 if isinstance(el2, cst.DictElement):
                     d[self.evaluate_in_scope(el2.key, scope)] = self.evaluate_in_scope(
-                        el2.value, scope, target_name, target_line
+                        el2.value, scope, target_line
                     )
             return d
         elif isinstance(item, cst.Subscript):
-            lhs = self.evaluate_in_scope(item.value, scope, target_name, target_line)
+            lhs = self.evaluate_in_scope(item.value, scope, target_line)
             if isinstance(lhs, str):
                 # A "??" entry, propagate
                 return "??"
 
             # TODO: Figure out why this is Sequence
             if isinstance(item.slice[0].slice, cst.Index):
                 rhs = self.evaluate_in_scope(
-                    item.slice[0].slice.value, scope, target_name, target_line
+                    item.slice[0].slice.value, scope, target_line
                 )
                 try:
                     if isinstance(lhs, dict):
@@ -338,8 +341,8 @@ def evaluate_in_scope(
                 # LOG.warning(f"Omit2 {type(item.slice[0].slice)!r}")
                 return "??"
         elif isinstance(item, cst.BinaryOperation):
-            lhs = self.evaluate_in_scope(item.left, scope, target_name, target_line)
-            rhs = self.evaluate_in_scope(item.right, scope, target_name, target_line)
+            lhs = self.evaluate_in_scope(item.left, scope, target_line)
+            rhs = self.evaluate_in_scope(item.right, scope, target_line)
             if lhs == "??" or rhs == "??":
                 return "??"
             if isinstance(item.operator, cst.Add):
@@ -350,8 +353,8 @@ def evaluate_in_scope(
             else:
                 return "??"
         elif isinstance(item, cst.AugAssign):
-            lhs = self.evaluate_in_scope(item.target, scope, target_name, target_line)
-            rhs = self.evaluate_in_scope(item.value, scope, target_name, target_line)
+            lhs = self.evaluate_in_scope(item.target, scope, target_line)
+            rhs = self.evaluate_in_scope(item.value, scope, target_line)
             if lhs == "??" or rhs == "??":
                 return "??"
             if isinstance(item.operator, cst.AddAssign):

dowsing/tests/setuptools.py

@@ -373,3 +373,23 @@ def test_self_reference_assignments(self) -> None:
         self.assertEqual(d.name, "foobar")
         self.assertEqual(d.version, "base.suffix")
         self.assertListEqual(d.classifiers, ["123", "abc", "xyz"])
+
+    def test_circular_references(self) -> None:
+        d = self._read(
+            """\
+from setuptools import setup
+
+name = "foo"
+
+foo = bar
+bar = version
+version = foo
+
+setup(
+    name=name,
+    version=version,
+)
+            """
+        )
+        self.assertEqual(d.name, "foo")
+        self.assertEqual(d.version, "??")