[IMP] util/misc: more coverage

More nodes + more tests

Author: aj-fuentes

src/base/tests/test_util.py

@@ -1686,6 +1686,25 @@ def adapter(node):
         self.assertEqual(repl, "result = this.get('x') if that.y == 2 else this.get('z')")
 
     @unittest.skipUnless(util.ast_unparse is not None, "`ast.unparse` available from Python3.9")
+    @unittest.skipUnless(hasattr(ast, "Constant"), "`ast.Constant` available from Python3.6")
+    def test_literal_replace_callable2(self):
+        def adapter2(node):
+            return ast.parse("{} / 42".format(node.left.value), mode="eval").body
+
+        def adapter3(node):
+            return ast.parse("y == 42", mode="eval").body
+
+        repl = util.literal_replace(
+            "16 * w or y == 2",
+            {
+                ast.BinOp(ast.Constant(16), ast.Mult(), ast.Name(util.literal_replace.WILDCARD)): adapter2,
+                ast.Compare(ast.Name("y"), [ast.Eq()], [ast.Constant(util.literal_replace.WILDCARD)]): adapter3,
+            },
+        )
+        self.assertEqual(repl, "16 / 42 or y == 42")
+
+    @unittest.skipUnless(util.ast_unparse is not None, "`ast.unparse` available from Python3.9")
+    @unittest.skipUnless(hasattr(ast, "Constant"), "`ast.Constant` available from Python3.6")
     def test_literal_replace_wildcards(self):
         repl = util.literal_replace(
             "x+1 - z* 18",
@@ -1695,7 +1714,7 @@ def test_literal_replace_wildcards(self):
 
     @parametrize(
         [
-            (ast.Attribute(ast.Name(util.literal_replace.WILDCARD), util.literal_replace.WILDCARD), "*.*"),
+            (ast.Attribute(ast.Name(util.literal_replace.WILDCARD, None), util.literal_replace.WILDCARD, None), "*.*"),
             (ast.Constant(util.literal_replace.WILDCARD), "*"),
             (
                 ast.BinOp(

src/util/misc.py

@@ -527,6 +527,9 @@ def __init__(self, mapping):
     def _no_match(self, left, right):
         return False
 
+    def _all_match(self, lefts, rights):
+        return len(lefts) == len(rights) and all(self._match(left_, right_) for left_, right_ in zip(lefts, rights))
+
     def _match(self, left, right):
         same_ctx = not hasattr(right, "ctx") or getattr(left, "ctx", None).__class__ is right.ctx.__class__
         cname = left.__class__.__name__
@@ -565,20 +568,33 @@ def _match_Tuple(self, left, right):
         return self._match_List(left, right)
 
     def _match_ListComp(self, left, right):
-        return (
-            self._match(left.elt, right.elt)
-            and len(left.generators) == len(right.generators)
-            and all(self._match(left_, right_) for left_, right_ in zip(left.generators, right.generators))
-        )
+        return self._match(left.elt, right.elt) and self._all_match(left.generators, right.generators)
 
     def _match_comprehension(self, left, right):
         return (
             # async is not expected in our use cases, just for completeness
             getattr(left, "is_async", 0) == getattr(right, "is_async", 0)
-            and len(left.ifs) == len(right.ifs)
             and self._match(left.target, right.target)
             and self._match(left.iter, right.iter)
-            and all(self._match(left_, right_) for left_, right_ in zip(left.ifs, right.ifs))
+            and self._all_match(left.ifs, right.ifs)
+        )
+
+    def _match_BinOp(self, left, right):
+        return (
+            left.op.__class__ is right.op.__class__
+            and self._match(left.left, right.left)
+            and self._match(left.right, right.right)
+        )
+
+    def _match_BoolOp(self, left, right):
+        return left.op.__class__ is right.op.__class__ and self._all_match(left.values, right.values)
+
+    def _match_Compare(self, left, right):
+        return (
+            len(left.ops) == len(right.ops)
+            and all(lop.__class__ is rop.__class__ for lop, rop in zip(left.ops, right.ops))
+            and self._match(left.left, right.left)
+            and self._all_match(left.comparators, right.comparators)
         )
 
     def visit(self, node):