Always enable ty type attribution for template parsing

TemplateEngine._parse_code previously only used TyTypesClient when
dependencies were specified. This meant patterns for stdlib functions
(e.g. json.dumps) were parsed without type attribution, preventing
Layer 2 FQN matching.

Now _parse_code always attempts ty: with dependencies it uses the
cached DependencyWorkspace; without, a temporary directory suffices
for stdlib and already-installed packages.

Switched FQN integration tests from six (ty 0.0.19 cannot resolve it)
to stdlib json.dumps which ty resolves consistently.

Author: knutwannheden

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

@@ -228,8 +228,10 @@ def _parse_code(cls, code: str, options: Optional[TemplateOptions] = None) -> 'C
         """
         Parse Python code into an LST CompilationUnit.
 
-        When *options* specifies dependencies, a cached workspace is created
-        and ``TyTypesClient`` is used for type attribution during parsing.
+        Always attempts type attribution via ``TyTypesClient``.  When
+        *options* specifies dependencies, a cached virtualenv workspace is
+        used; otherwise a temporary directory suffices (enough for stdlib
+        and already-installed packages).
 
         Args:
             code: Python source code.
@@ -244,27 +246,33 @@ def _parse_code(cls, code: str, options: Optional[TemplateOptions] = None) -> 'C
 
         ty_client = None
         tmp_file = None
+        owns_workspace = False
+        workspace = None
         try:
-            if options and options.dependencies:
-                try:
-                    import tempfile as _tmpmod
-                    from .dependency_workspace import DependencyWorkspace
-                    from rewrite.python.ty_client import TyTypesClient
+            try:
+                import tempfile as _tmpmod
+                from rewrite.python.ty_client import TyTypesClient
 
+                if options and options.dependencies:
+                    from .dependency_workspace import DependencyWorkspace
                     workspace = DependencyWorkspace.get_or_create(options.dependencies)
-                    ty_client = TyTypesClient()
-                    ty_client.initialize(workspace)
-
-                    # ty needs a real file path for type resolution
-                    fd, tmp_file = _tmpmod.mkstemp(suffix=".py", dir=workspace)
-                    try:
-                        os.write(fd, code.encode())
-                    finally:
-                        os.close(fd)
-                except (ImportError, RuntimeError):
-                    # uv or ty-types not available — parse without type attribution
-                    ty_client = None
-                    tmp_file = None
+                else:
+                    workspace = _tmpmod.mkdtemp()
+                    owns_workspace = True
+
+                ty_client = TyTypesClient()
+                ty_client.initialize(workspace)
+
+                # ty needs a real file path for type resolution
+                fd, tmp_file = _tmpmod.mkstemp(suffix=".py", dir=workspace)
+                try:
+                    os.write(fd, code.encode())
+                finally:
+                    os.close(fd)
+            except (ImportError, RuntimeError):
+                # ty-types not available — parse without type attribution
+                ty_client = None
+                tmp_file = None
 
             visitor = ParserVisitor(code, file_path=tmp_file, ty_client=ty_client)
             return visitor.visit(tree)
@@ -276,6 +284,9 @@ def _parse_code(cls, code: str, options: Optional[TemplateOptions] = None) -> 'C
                     os.unlink(tmp_file)
                 except OSError:
                     pass
+            if owns_workspace and workspace is not None:
+                import shutil
+                shutil.rmtree(workspace, ignore_errors=True)
 
     @classmethod
     def _extract_from_wrapper(cls, cu: 'CompilationUnit', is_expression: bool) -> J:

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

@@ -14,7 +14,6 @@
 
 """Tests for Template class."""
 
-import shutil
 from typing import Any, Optional
 from uuid import uuid4
 
@@ -29,7 +28,7 @@
 from rewrite.python.template.engine import TemplateEngine
 from rewrite.python.template.replacement import maybe_parenthesize
 from rewrite.python.visitor import PythonVisitor
-from rewrite.test import RecipeSpec, python, pyproject, uv
+from rewrite.test import RecipeSpec, python
 from rewrite.visitor import Cursor
 
 
@@ -660,37 +659,36 @@ def test_builder_with_dependencies(self):
         assert tmpl._options.dependencies == (("requests", "2.31.0"),)
 
 
-@pytest.mark.skipif(not shutil.which("uv"), reason="uv not installed")
 class TestTypeAttributedPatternMatching:
     """Integration tests for pattern matching with type attribution.
 
-    These tests verify that uv() + pyproject() + pattern(dependencies=...)
-    produce type-attributed ASTs that the 3-layer comparator can use for
-    FQN-based semantic matching.
+    These tests use stdlib ``json.dumps`` (no external dependencies) to verify
+    that type-attributed ASTs enable FQN-based semantic matching in the 3-layer
+    comparator.  ``ty`` consistently resolves ``json.dumps`` to
+    ``declaring_fqn=json`` regardless of import style.
     """
 
     def test_fqn_match_different_import_styles(self):
         """Pattern matches code that uses a different import style via FQN.
 
-        Code uses ``from six import ensure_str; ensure_str(x)`` (bare name).
-        Pattern uses ``six.ensure_str({val})`` (qualified name).
+        Code uses ``from json import dumps; dumps(x)`` (bare name).
+        Pattern uses ``json.dumps({val})`` (qualified name).
         Without type attribution, these would NOT structurally match because
-        the select (None vs Identifier("six")) differs.  With type attribution,
-        Layer 2 FQN matching detects both resolve to ``six.ensure_str`` and
+        the select (None vs Identifier("json")) differs.  With type attribution,
+        Layer 2 FQN matching detects both resolve to ``json.dumps`` and
         skips the select comparison.
         """
         val = capture('val')
         pat = pattern(
-            f"six.ensure_str({val})",
-            imports=["import six"],
-            dependencies={"six": "1.17.0"},
+            f"json.dumps({val})",
+            context=["import json"],
         )
         tmpl = template(f"str({val})")
 
-        class ReplaceSixEnsureStr(Recipe):
+        class ReplaceJsonDumps(Recipe):
             @property
             def name(self):
-                return "test.ReplaceSixEnsureStr"
+                return "test.ReplaceJsonDumps"
 
             @property
             def display_name(self):
@@ -710,53 +708,41 @@ def visit_method_invocation(self, method, p):
                         return method
                 return Visitor()
 
-        spec = RecipeSpec(recipe=ReplaceSixEnsureStr())
+        spec = RecipeSpec(recipe=ReplaceJsonDumps())
         spec.rewrite_run(
-            *uv(
-                pyproject(
-                    """
-                    [project]
-                    name = "test"
-                    version = "0.0.0"
-                    requires-python = ">=3.10"
-                    dependencies = ["six==1.17.0"]
-                    """
-                ),
-                python(
-                    """
-                    from six import ensure_str
-                    x = ensure_str("hello")
-                    """,
-                    """
-                    from six import ensure_str
-                    x = str("hello")
-                    """,
-                ),
-            )
+            python(
+                """
+                from json import dumps
+                x = dumps({"key": "value"})
+                """,
+                """
+                from json import dumps
+                x = str({"key": "value"})
+                """,
+            ),
         )
 
     def test_fqn_match_with_aliased_import(self):
         """Pattern matches code that uses an aliased import via FQN.
 
-        Code uses ``import six as s; s.ensure_str(x)`` (aliased select ``s``).
-        Pattern uses ``six.ensure_str({val})`` (canonical select ``six``).
-        Without type attribution, ``Identifier("s")`` != ``Identifier("six")``
+        Code uses ``import json as j; j.dumps(x)`` (aliased select ``j``).
+        Pattern uses ``json.dumps({val})`` (canonical select ``json``).
+        Without type attribution, ``Identifier("j")`` != ``Identifier("json")``
         so the structural comparison would fail.  With type attribution,
-        Layer 2 FQN matching detects both resolve to ``six.ensure_str``
+        Layer 2 FQN matching detects both resolve to ``json.dumps``
         and skips the select comparison entirely.
         """
         val = capture('val')
         pat = pattern(
-            f"six.ensure_str({val})",
-            imports=["import six"],
-            dependencies={"six": "1.17.0"},
+            f"json.dumps({val})",
+            context=["import json"],
         )
         tmpl = template(f"str({val})")
 
-        class ReplaceSixEnsureStr(Recipe):
+        class ReplaceJsonDumps(Recipe):
             @property
             def name(self):
-                return "test.ReplaceSixEnsureStr"
+                return "test.ReplaceJsonDumps"
 
             @property
             def display_name(self):
@@ -776,27 +762,16 @@ def visit_method_invocation(self, method, p):
                         return method
                 return Visitor()
 
-        spec = RecipeSpec(recipe=ReplaceSixEnsureStr())
+        spec = RecipeSpec(recipe=ReplaceJsonDumps())
         spec.rewrite_run(
-            *uv(
-                pyproject(
-                    """
-                    [project]
-                    name = "test"
-                    version = "0.0.0"
-                    requires-python = ">=3.10"
-                    dependencies = ["six==1.17.0"]
-                    """
-                ),
-                python(
-                    """
-                    import six as s
-                    x = s.ensure_str("hello")
-                    """,
-                    """
-                    import six as s
-                    x = str("hello")
-                    """,
-                ),
-            )
+            python(
+                """
+                import json as j
+                x = j.dumps({"key": "value"})
+                """,
+                """
+                import json as j
+                x = str({"key": "value"})
+                """,
+            ),
         )