Python: Fix cross-type literal matching in pattern comparator

Literal comparison (`_compare_literal`) previously only checked value
equality, which could produce false positives when different literal
types share the same internal representation (e.g., `None`, `...`, and
unicode-escaped strings all store `value=None`).

The fix adds two-level comparison:
1. Reject immediately when value types differ (NoneType vs bytes, etc.)
2. Fall back to `value_source` comparison when both values are `None`
   to distinguish `None` from `...` and unicode-escaped literals.

This prevents patterns like `{x} == None` from matching byte string
comparisons like `x == b""`.

Author: knutwannheden

rewrite-python/rewrite/src/rewrite/python/template/comparator.py

@@ -222,7 +222,19 @@ def _compare_identifier(self, pattern: j.Identifier, target: j.Identifier) -> bo
         return pattern.simple_name == target.simple_name
 
     def _compare_literal(self, pattern: j.Literal, target: j.Literal) -> bool:
-        """Compare two literals."""
+        """Compare two literals.
+
+        Uses a two-level comparison:
+        1. Value types must match (prevents cross-type false positives like
+           None vs b"" where both might serialize to the same representation).
+        2. When both values are None (Ellipsis, None keyword, or literals with
+           unicode escapes all store value=None), fall back to value_source
+           comparison to distinguish them.
+        """
+        if type(pattern.value) != type(target.value):
+            return False
+        if pattern.value is None:
+            return pattern.value_source == target.value_source
         return pattern.value == target.value
 
     def _compare_method_invocation(

rewrite-python/rewrite/tests/python/template/test_comparator.py

@@ -128,6 +128,86 @@ def test_mismatched_string_literals_no_match(self):
         assert result is None
 
 
+class TestCrossTypeLiteralMatching:
+    """Tests that literals of different Python types never match each other."""
+
+    def setup_method(self):
+        TemplateEngine.clear_cache()
+
+    def teardown_method(self):
+        TemplateEngine.clear_cache()
+
+    def test_none_does_not_match_bytes_literal(self):
+        """None should not match b''."""
+        pattern_tree = TemplateEngine.get_template_tree("None", {})
+        target_tree = TemplateEngine.get_template_tree('b""', {})
+        cursor = _make_cursor(target_tree)
+
+        comparator = PatternMatchingComparator({})
+        result = comparator.match(pattern_tree, target_tree, cursor)
+        assert result is None
+
+    def test_none_does_not_match_nonempty_bytes(self):
+        """None should not match b'hello'."""
+        pattern_tree = TemplateEngine.get_template_tree("None", {})
+        target_tree = TemplateEngine.get_template_tree('b"hello"', {})
+        cursor = _make_cursor(target_tree)
+
+        comparator = PatternMatchingComparator({})
+        result = comparator.match(pattern_tree, target_tree, cursor)
+        assert result is None
+
+    def test_none_does_not_match_empty_string(self):
+        """None should not match ''."""
+        pattern_tree = TemplateEngine.get_template_tree("None", {})
+        target_tree = TemplateEngine.get_template_tree('""', {})
+        cursor = _make_cursor(target_tree)
+
+        comparator = PatternMatchingComparator({})
+        result = comparator.match(pattern_tree, target_tree, cursor)
+        assert result is None
+
+    def test_none_does_not_match_zero(self):
+        """None should not match 0."""
+        pattern_tree = TemplateEngine.get_template_tree("None", {})
+        target_tree = TemplateEngine.get_template_tree("0", {})
+        cursor = _make_cursor(target_tree)
+
+        comparator = PatternMatchingComparator({})
+        result = comparator.match(pattern_tree, target_tree, cursor)
+        assert result is None
+
+    def test_none_matches_none(self):
+        """None should match None."""
+        pattern_tree = TemplateEngine.get_template_tree("None", {})
+        target_tree = TemplateEngine.get_template_tree("None", {})
+        cursor = _make_cursor(target_tree)
+
+        comparator = PatternMatchingComparator({})
+        result = comparator.match(pattern_tree, target_tree, cursor)
+        assert result is not None
+
+    def test_none_does_not_match_ellipsis(self):
+        """None should not match ... (Ellipsis) — both have value=None internally."""
+        pattern_tree = TemplateEngine.get_template_tree("None", {})
+        target_tree = TemplateEngine.get_template_tree("...", {})
+        cursor = _make_cursor(target_tree)
+
+        comparator = PatternMatchingComparator({})
+        result = comparator.match(pattern_tree, target_tree, cursor)
+        assert result is None
+
+    def test_bytes_does_not_match_string(self):
+        """b'hello' should not match 'hello'."""
+        pattern_tree = TemplateEngine.get_template_tree('b"hello"', {})
+        target_tree = TemplateEngine.get_template_tree('"hello"', {})
+        cursor = _make_cursor(target_tree)
+
+        comparator = PatternMatchingComparator({})
+        result = comparator.match(pattern_tree, target_tree, cursor)
+        assert result is None
+
+
 class TestMethodInvocationMatching:
     """Tests for method invocation comparison."""