bpo-15987: Implement ast.compare

isidentical · isidentical · commit cfb508ff34d0 · 2020-03-28T23:50:29.000+03:00
diff --git a/Doc/library/ast.rst b/Doc/library/ast.rst
@@ -1748,6 +1748,17 @@ and classes for traversing abstract syntax trees:
       Added the *indent* option.
 
 
+.. function:: compare(a, b, /, *, compare_types=True, compare_fields=True, compare_attributes=False)
+
+    Recursively compare given 2 AST nodes. If *compare_types* is ``False``, the
+    field values won't be checked whether they belong to same type or not. If
+    *compare_fields* is ``True``, members of ``_fields`` attribute on both node's
+    type will be checked. If *compare_attributes* is ``True``, members of
+    ``_attributes`` attribute on both node's will be compared.
+
+   .. versionadded:: 3.9
+
+
 .. _ast-cli:
 
 Command-Line Usage
diff --git a/Doc/whatsnew/3.9.rst b/Doc/whatsnew/3.9.rst
@@ -167,6 +167,9 @@ that would produce an equivalent :class:`ast.AST` object when parsed.
 Added docstrings to AST nodes that contains the ASDL signature used to
 construct that node. (Contributed by Batuhan Taskaya in :issue:`39638`.)
 
+Added :func:`ast.compare` for comparing 2 AST node.
+(Contributed by Batuhan Taskaya in :issue:`15987`)
+
 asyncio
 -------
 
diff --git a/Lib/ast.py b/Lib/ast.py
@@ -368,6 +368,69 @@ def walk(node):
         yield node
 
 
+def compare(
+    a,
+    b,
+    /,
+    *,
+    compare_types=True,
+    compare_fields=True,
+    compare_attributes=False,
+):
+    """
+    Compares recursively given two ast nodes. If *compare_types* is False, the
+    field values won't be checked whether they belong to same type or not. If
+    *compare_fields* is True, members of `_fields` attribute on both node's type
+    will be checked. If *compare_attributes* is True, members of `_attributes`
+    attribute on both node's will be compared.
+    """
+
+    def _compare(a, b):
+        if compare_types and type(a) is not type(b):
+            return False
+        elif isinstance(a, AST):
+            return compare(
+                a,
+                b,
+                compare_attributes=compare_attributes,
+                compare_fields=compare_fields,
+                compare_types=compare_types,
+            )
+        elif isinstance(a, list):
+            if len(a) != len(b):
+                return False
+            for a_item, b_item in zip(a, b):
+                if not _compare(a_item, b_item):
+                    return False
+            else:
+                return True
+        else:
+            return a == b
+
+    def _compare_member(member):
+        for field in getattr(a, member):
+            if not hasattr(a, field) and not hasattr(b, field):
+                continue
+            if not (hasattr(a, field) and hasattr(b, field)):
+                return False
+            a_field = getattr(a, field)
+            b_field = getattr(b, field)
+            if not _compare(a_field, b_field):
+                return False
+        else:
+            return True
+
+    if type(a) is not type(b):
+        return False
+    if compare_fields:
+        if not _compare_member("_fields"):
+            return False
+    if compare_attributes:
+        if not _compare_member("_attributes"):
+            return False
+    return True
+
+
 class NodeVisitor(object):
     """
     A node visitor base class that walks the abstract syntax tree and calls a
diff --git a/Lib/test/test_ast.py b/Lib/test/test_ast.py
@@ -1,7 +1,9 @@
 import ast
 import dis
 import os
+import random
 import sys
+import tokenize
 import unittest
 import warnings
 import weakref
@@ -25,6 +27,9 @@ def to_tuple(t):
         result.append(to_tuple(getattr(t, f)))
     return tuple(result)
 
+STDLIB = os.path.dirname(ast.__file__)
+STDLIB_FILES = [fn for fn in os.listdir(STDLIB) if fn.endswith(".py")]
+STDLIB_FILES.extend(["test/test_grammar.py", "test/test_unpack_ex.py"])
 
 # These tests are compiled through "exec"
 # There should be at least one test per statement
@@ -654,6 +659,110 @@ def test_ast_asdl_signature(self):
         expressions[0] = f"expr = {ast.expr.__subclasses__()[0].__doc__}"
         self.assertCountEqual(ast.expr.__doc__.split("\n"), expressions)
 
+        self.assertTrue(ast.compare(ast.parse("x = 10"), ast.parse("x = 10")))
+        self.assertFalse(ast.compare(ast.parse("x = 10"), ast.parse("")))
+        self.assertFalse(ast.compare(ast.parse("x = 10"), ast.parse("x")))
+        self.assertFalse(
+            ast.compare(ast.parse("x = 10;y = 20"), ast.parse("class C:pass"))
+        )
+
+    def test_compare_literals(self):
+        constants = (
+            -20,
+            20,
+            20.0,
+            1,
+            1.0,
+            True,
+            0,
+            False,
+            frozenset(),
+            tuple(),
+            "ABCD",
+            "abcd",
+            "中文字",
+            1e1000,
+            -1e1000,
+        )
+        for next_index, constant in enumerate(constants[:-1], 1):
+            next_constant = constants[next_index]
+            with self.subTest(literal=constant, next_literal=next_constant):
+                self.assertTrue(
+                    ast.compare(ast.Constant(constant), ast.Constant(constant))
+                )
+                self.assertFalse(
+                    ast.compare(
+                        ast.Constant(constant), ast.Constant(next_constant)
+                    )
+                )
+
+        same_looking_literal_cases = [
+            {1, 1.0, True, 1 + 0j},
+            {0, 0.0, False, 0 + 0j},
+        ]
+        for same_looking_literals in same_looking_literal_cases:
+            for literal in same_looking_literals:
+                for same_looking_literal in same_looking_literals - {literal}:
+                    self.assertFalse(
+                        ast.compare(
+                            ast.Constant(literal),
+                            ast.Constant(same_looking_literal),
+                        )
+                    )
+
+    def test_compare_fieldless(self):
+        self.assertTrue(ast.compare(ast.Add(), ast.Add()))
+        self.assertFalse(ast.compare(ast.Sub(), ast.Add()))
+        self.assertFalse(ast.compare(ast.Sub(), ast.Constant()))
+
+    def test_compare_stdlib(self):
+        if support.is_resource_enabled("cpu"):
+            files = STDLIB_FILES
+        else:
+            files = random.sample(STDLIB_FILES, 10)
+
+        for module in files:
+            with self.subTest(module):
+                fn = os.path.join(STDLIB, module)
+                with tokenize.open(fn) as fp:
+                    source = fp.read()
+                a = ast.parse(source, fn)
+                b = ast.parse(source, fn)
+                self.assertTrue(
+                    ast.compare(a, b), f"{ast.dump(a)} != {ast.dump(b)}"
+                )
+
+    def test_compare_tests(self):
+        for mode, sources in (
+            ("exec", exec_tests),
+            ("eval", eval_tests),
+            ("single", single_tests),
+        ):
+            for source in sources:
+                a = ast.parse(source, mode=mode)
+                b = ast.parse(source, mode=mode)
+                self.assertTrue(
+                    ast.compare(a, b), f"{ast.dump(a)} != {ast.dump(b)}"
+                )
+
+    def test_compare_options(self):
+        def parse(a, b):
+            return ast.parse(a), ast.parse(b)
+
+        a, b = parse("2 + 2", "2+2")
+        self.assertTrue(ast.compare(a, b, compare_attributes=False))
+        self.assertFalse(ast.compare(a, b, compare_attributes=True))
+
+        a, b = parse("1", "1.0")
+        self.assertTrue(ast.compare(a, b, compare_types=False))
+        self.assertFalse(ast.compare(a, b, compare_types=True))
+
+        a, b = parse("1", "2")
+        self.assertTrue(ast.compare(a, b, compare_fields=False, compare_attributes=False))
+        self.assertTrue(ast.compare(a, b, compare_fields=False, compare_attributes=True))
+        self.assertFalse(ast.compare(a, b, compare_fields=True, compare_attributes=False))
+        self.assertFalse(ast.compare(a, b, compare_fields=True, compare_attributes=True))
+
 
 class ASTHelpers_Test(unittest.TestCase):
     maxDiff = None
@@ -1369,12 +1478,9 @@ def test_nameconstant(self):
         self.expr(ast.NameConstant(4))
 
     def test_stdlib_validates(self):
-        stdlib = os.path.dirname(ast.__file__)
-        tests = [fn for fn in os.listdir(stdlib) if fn.endswith(".py")]
-        tests.extend(["test/test_grammar.py", "test/test_unpack_ex.py"])
-        for module in tests:
+        for module in STDLIB_FILES:
             with self.subTest(module):
-                fn = os.path.join(stdlib, module)
+                fn = os.path.join(STDLIB, module)
                 with open(fn, "r", encoding="utf-8") as fp:
                     source = fp.read()
                 mod = ast.parse(source, fn)
diff --git a/Misc/NEWS.d/next/Library/2020-03-28-21-00-54.bpo-15987.aBL8XS.rst b/Misc/NEWS.d/next/Library/2020-03-28-21-00-54.bpo-15987.aBL8XS.rst
@@ -0,0 +1,2 @@
+Implemented :func:`ast.compare` for comparing 2 AST node. Patch by Batuhan
+Taskaya.

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	+Implemented :func:`ast.compare` for comparing 2 AST node. Patch by Batuhan
	`2`	`+Taskaya.`