add helper to convert nodes to matchers (#1351)

* add helper to convert nodes to matchers

* suppress type error

Author: zsol

libcst/helpers/matchers.py

@@ -0,0 +1,45 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+from dataclasses import fields, is_dataclass, MISSING
+
+from libcst import matchers
+from libcst._nodes.base import CSTNode
+
+
+def node_to_matcher(
+    node: CSTNode, *, match_syntactic_trivia: bool = False
+) -> matchers.BaseMatcherNode:
+    """Convert a concrete node to a matcher."""
+    if not is_dataclass(node):
+        raise ValueError(f"{node} is not a CSTNode")
+
+    attrs = {}
+    for field in fields(node):
+        name = field.name
+        child = getattr(node, name)
+        if not match_syntactic_trivia and field.name.startswith("whitespace"):
+            # Not all nodes have whitespace fields, some have multiple, but they all
+            # start with whitespace*
+            child = matchers.DoNotCare()
+        elif field.default is not MISSING and child == field.default:
+            child = matchers.DoNotCare()
+        # pyre-ignore[29]: Union[MISSING_TYPE, ...] is not a function.
+        elif field.default_factory is not MISSING and child == field.default_factory():
+            child = matchers.DoNotCare()
+        elif isinstance(child, (list, tuple)):
+            child = type(child)(
+                node_to_matcher(item, match_syntactic_trivia=match_syntactic_trivia)
+                for item in child
+            )
+        elif hasattr(matchers, type(child).__name__):
+            child = node_to_matcher(
+                child, match_syntactic_trivia=match_syntactic_trivia
+            )
+        attrs[name] = child
+
+    matcher = getattr(matchers, type(node).__name__)
+    return matcher(**attrs)

libcst/helpers/tests/test_matchers.py

@@ -0,0 +1,53 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+from libcst import parse_expression, parse_statement
+from libcst.helpers.matchers import node_to_matcher
+from libcst.matchers import matches
+from libcst.testing.utils import data_provider, UnitTest
+
+
+class MatchersTest(UnitTest):
+    @data_provider(
+        (
+            ('"some string"',),
+            ("call(some, **kwargs)",),
+            ("a[b.c]",),
+            ("[1 for _ in range(99) if False]",),
+        )
+    )
+    def test_reflexive_expressions(self, code: str) -> None:
+        node = parse_expression(code)
+        matcher = node_to_matcher(node)
+        self.assertTrue(matches(node, matcher))
+
+    @data_provider(
+        (
+            ("def foo(a) -> None: pass",),
+            ("class F: ...",),
+            ("foo: bar",),
+        )
+    )
+    def test_reflexive_statements(self, code: str) -> None:
+        node = parse_statement(code)
+        matcher = node_to_matcher(node)
+        self.assertTrue(matches(node, matcher))
+
+    def test_whitespace(self) -> None:
+        code_ws = parse_expression("(foo  ,   bar  )")
+        code = parse_expression("(foo,bar)")
+        self.assertTrue(
+            matches(
+                code,
+                node_to_matcher(code_ws),
+            )
+        )
+        self.assertFalse(
+            matches(
+                code,
+                node_to_matcher(code_ws, match_syntactic_trivia=True),
+            )
+        )