Merge branch 'main' into fix-declarative-recipe-scanning-accumulator

Author: salockhart

rewrite-javascript/build.gradle.kts

@@ -2,6 +2,8 @@
 
 import com.github.gradle.node.NodeExtension
 import com.github.gradle.node.npm.task.NpmTask
+import com.gradle.develocity.agent.gradle.test.ImportJUnitXmlReports
+import com.gradle.develocity.agent.gradle.test.JUnitXmlDialect
 import nl.javadude.gradle.plugins.license.LicenseExtension
 import java.time.LocalDateTime
 import java.time.format.DateTimeFormatter
@@ -112,6 +114,8 @@ val npmTest = tasks.register<NpmTask>("npmTest") {
     args = listOf("run", "ci:test")
 }
 
+ImportJUnitXmlReports.register(tasks, npmTest, JUnitXmlDialect.GENERIC)
+
 tasks.named("check") {
     dependsOn(npmTest)
 }

rewrite-python/build.gradle.kts

@@ -1,5 +1,7 @@
 @file:Suppress("UnstableApiUsage")
 
+import com.gradle.develocity.agent.gradle.test.ImportJUnitXmlReports
+import com.gradle.develocity.agent.gradle.test.JUnitXmlDialect
 import nl.javadude.gradle.plugins.license.LicenseExtension
 import java.time.LocalDateTime
 import java.time.format.DateTimeFormatter
@@ -163,13 +165,21 @@ val pytestTest by tasks.registering(Exec::class) {
     dependsOn(pythonInstall)
 
     workingDir = pythonDir
-    commandLine(pythonExe.absolutePath, "-m", "pytest", "tests/", "-v")
+    commandLine(pythonExe.absolutePath, "-m", "pytest", "tests/", "-v",
+        "--junitxml=build/test-results/pytest/junit.xml")
 
     inputs.dir(pythonDir.resolve("src"))
+        .withPathSensitivity(PathSensitivity.RELATIVE)
     inputs.dir(pythonDir.resolve("tests"))
+        .withPathSensitivity(PathSensitivity.RELATIVE)
     inputs.file(pythonDir.resolve("pyproject.toml"))
+        .withPathSensitivity(PathSensitivity.RELATIVE)
+    outputs.file(pythonDir.resolve("build/test-results/pytest/junit.xml"))
+    outputs.cacheIf { true }
 }
 
+ImportJUnitXmlReports.register(tasks, pytestTest, JUnitXmlDialect.GENERIC)
+
 tasks.named("check") {
     dependsOn(testing.suites.named("py2CompatibilityTest"))
     dependsOn(pytestTest)

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."""