Add type attribution tests and fix method declaration/type hint types (#6794)

- Add type attribution tests to 13 existing parser test files covering
  method invocations, binary ops, type hints, collection literals, imports,
  field access, class instances, method declarations, async defs, for loops,
  unary ops, ternaries, and lambdas
- Add `method_declaration_type()` to type_mapping.py to build JavaType.Method
  for function declarations using ty-types descriptor data with annotation fallback
- Add type attribution to ParameterizedType nodes in type hint expressions
- Fix pre-existing assign_test.py bug (simple_name access, FQN startswith)
- Add typing.Text test to test_type_attribution.py
- Bump ty-types dependency to >=0.0.19.dev20260223093555

Author: knutwannheden

rewrite-python/rewrite/pyproject.toml

@@ -24,7 +24,7 @@ requires-python = ">=3.10"
 dependencies = [
     "cbor2>=5.6.5",
     "more_itertools>=10.0.0",
-    "ty-types>=0.0.18.dev0",  # Type inference CLI for Python type attribution
+    "ty-types>=0.0.19.dev20260223093555",  # Type inference CLI for Python type attribution
     "parso>=0.7.1,<0.8",  # Python 2/3 parser with CST support (0.8+ dropped Python 2.7 grammar)
 ]
 

rewrite-python/rewrite/src/rewrite/python/_parser_visitor.py

@@ -2182,7 +2182,7 @@ def visit_FunctionDef(self, node: ast.FunctionDef) -> j.MethodDeclaration:
             None,
             body,
             None,
-            self.__as_method_type(self._type_mapping.type(node)),
+            self._type_mapping.method_declaration_type(node),
         )
 
     def __map_decorator(self, decorator) -> j.Annotation:
@@ -2871,7 +2871,7 @@ def __convert_type_mapper(self, node) -> Optional[TypeTree]:
                      enumerate(slices)],
                     Markers.EMPTY
                 ),
-                None
+                self._type_mapping.type(node)
             )
         elif isinstance(node, ast.BinOp):
             # Type unions using `|` was added in Python 3.10

rewrite-python/rewrite/src/rewrite/python/type_mapping.py

@@ -618,6 +618,87 @@ def attribute_type_info(self, node: ast.Attribute,
             return expr_type, JavaType.Variable(_name=node.attr, _type=expr_type, _owner=receiver_type)
         return expr_type, None
 
+    def method_declaration_type(self, node: ast.FunctionDef) -> Optional[JavaType.Method]:
+        """Get the method type for a function/method declaration.
+
+        Builds a JavaType.Method from the function's type descriptor when
+        available (parameters + returnType fields), falling back to resolving
+        parameter annotations and return annotation individually via ty-types.
+
+        Args:
+            node: The ast.FunctionDef or ast.AsyncFunctionDef node.
+
+        Returns:
+            A JavaType.Method, or None if types cannot be determined.
+        """
+        # First try: use structured data from the function descriptor
+        type_id = self._lookup_type_id(node)
+        if type_id is not None:
+            descriptor = self._type_registry.get(type_id)
+            if descriptor and descriptor.get('kind') in ('function', 'boundMethod'):
+                # If the descriptor has parameters/returnType, use them directly
+                params = descriptor.get('parameters')
+                ret_id = descriptor.get('returnType')
+                if params is not None or ret_id is not None:
+                    return self._method_from_function_descriptor(
+                        descriptor, node.name)
+
+        # Fallback: build from individual parameter/return annotation types
+        param_names: List[str] = []
+        param_types: List[JavaType] = []
+        for arg in node.args.args:
+            if arg.arg in ('self', 'cls'):
+                continue
+            param_names.append(arg.arg)
+            if arg.annotation is not None:
+                t = self.type(arg.annotation)
+                param_types.append(t if t is not None else _UNKNOWN)
+            else:
+                param_types.append(_UNKNOWN)
+
+        return_type = None
+        if node.returns is not None:
+            return_type = self.type(node.returns)
+
+        if not param_names and return_type is None:
+            return None
+
+        return JavaType.Method(
+            _flags_bit_map=0,
+            _declaring_type=None,
+            _name=node.name,
+            _return_type=return_type,
+            _parameter_names=param_names if param_names else None,
+            _parameter_types=param_types if param_types else None,
+        )
+
+    def _method_from_function_descriptor(
+            self, descriptor: Dict[str, Any], name: str
+    ) -> JavaType.Method:
+        """Build a JavaType.Method from a function descriptor with parameters/returnType."""
+        param_names: List[str] = []
+        param_types: List[JavaType] = []
+        for param in descriptor.get('parameters', []):
+            p_name = param.get('name', '')
+            if p_name in ('self', 'cls'):
+                continue
+            param_names.append(p_name)
+            param_types.append(self._resolve_param_type(param))
+
+        return_type = None
+        ret_id = descriptor.get('returnType')
+        if ret_id is not None:
+            return_type = self._resolve_type(ret_id)
+
+        return JavaType.Method(
+            _flags_bit_map=0,
+            _declaring_type=None,
+            _name=name,
+            _return_type=return_type,
+            _parameter_names=param_names if param_names else None,
+            _parameter_types=param_types if param_types else None,
+        )
+
     def method_invocation_type(self, node: ast.Call) -> Optional[JavaType.Method]:
         """Get the method type for a function/method call.
 

rewrite-python/rewrite/tests/python/all/tree/assign_test.py

@@ -169,16 +169,16 @@ def visit_assignment(self, assignment, p):
                     if not assignment.type._type_parameters:
                         errors.append("Parameterized._type_parameters is empty")
                 elif isinstance(assignment.type, JavaType.Class):
-                    if assignment.type._fully_qualified_name != 'list':
-                        errors.append(f"Assignment.type fqn is '{assignment.type._fully_qualified_name}', expected 'list'")
+                    if not assignment.type._fully_qualified_name.startswith('list'):
+                        errors.append(f"Assignment.type fqn is '{assignment.type._fully_qualified_name}', expected to start with 'list'")
                 else:
                     errors.append(f"Assignment.type is {type(assignment.type).__name__}, expected Parameterized or Class")
                 return assignment
 
             def visit_method_invocation(self, method, p):
                 if not isinstance(method, MethodInvocation):
                     return method
-                if method.simple_name != 'split':
+                if method.name.simple_name != 'split':
                     return method
                 # method_type should be populated
                 if method.method_type is None:
@@ -194,11 +194,11 @@ def visit_method_invocation(self, method, p):
                 if method.method_type is not None and method.method_type._return_type is not None:
                     rt = method.method_type._return_type
                     if isinstance(rt, Parameterized):
-                        if rt._type._fully_qualified_name != 'list':
-                            errors.append(f"return_type fqn is '{rt._type._fully_qualified_name}', expected 'list'")
+                        if not rt._type._fully_qualified_name.startswith('list'):
+                            errors.append(f"return_type fqn is '{rt._type._fully_qualified_name}', expected to start with 'list'")
                     elif isinstance(rt, JavaType.Class):
-                        if rt._fully_qualified_name != 'list':
-                            errors.append(f"return_type fqn is '{rt._fully_qualified_name}', expected 'list'")
+                        if not rt._fully_qualified_name.startswith('list'):
+                            errors.append(f"return_type fqn is '{rt._fully_qualified_name}', expected to start with 'list'")
                     else:
                         errors.append(f"return_type is {type(rt).__name__}, expected Parameterized or Class")
                 return method

rewrite-python/rewrite/tests/python/all/tree/binary_test.py

@@ -1,7 +1,18 @@
+import shutil
+
 import pytest
 
+from rewrite.java.support_types import JavaType
+from rewrite.java.tree import Binary
+from rewrite.python.tree import CompilationUnit
+from rewrite.python.visitor import PythonVisitor
 from rewrite.test import RecipeSpec, python
 
+requires_ty_cli = pytest.mark.skipif(
+    shutil.which('ty-types') is None,
+    reason="ty-types CLI is not installed"
+)
+
 
 def test_bool_ops():
     # language=python
@@ -95,3 +106,93 @@ def test_multiline_tuple_comparison():
         , False) is not None
         """,
     ),)
+
+
+@requires_ty_cli
+def test_arithmetic_type_attribution():
+    """Verify that 1 + 2 has type Int."""
+    errors = []
+
+    def check_types(source_file):
+        assert isinstance(source_file, CompilationUnit)
+
+        class TypeChecker(PythonVisitor):
+            def visit_binary(self, binary, p):
+                if not isinstance(binary, Binary):
+                    return binary
+                if binary.operator != Binary.Type.Addition:
+                    return binary
+                if binary.type is None:
+                    errors.append("Binary(Addition).type is None")
+                elif binary.type != JavaType.Primitive.Int:
+                    errors.append(f"Binary(Addition).type is {binary.type}, expected Primitive.Int")
+                return binary
+
+        TypeChecker().visit(source_file, None)
+
+    # language=python
+    RecipeSpec(type_attribution=True).rewrite_run(python(
+        "x = 1 + 2",
+        after_recipe=check_types,
+    ))
+    assert not errors, "Type attribution errors:\n" + "\n".join(f"  - {e}" for e in errors)
+
+
+@requires_ty_cli
+def test_comparison_type_attribution():
+    """Verify that 1 < 2 has type Boolean."""
+    errors = []
+
+    def check_types(source_file):
+        assert isinstance(source_file, CompilationUnit)
+
+        class TypeChecker(PythonVisitor):
+            def visit_binary(self, binary, p):
+                if not isinstance(binary, Binary):
+                    return binary
+                if binary.operator != Binary.Type.LessThan:
+                    return binary
+                if binary.type is None:
+                    errors.append("Binary(LessThan).type is None")
+                elif binary.type != JavaType.Primitive.Boolean:
+                    errors.append(f"Binary(LessThan).type is {binary.type}, expected Primitive.Boolean")
+                return binary
+
+        TypeChecker().visit(source_file, None)
+
+    # language=python
+    RecipeSpec(type_attribution=True).rewrite_run(python(
+        "x = 1 < 2",
+        after_recipe=check_types,
+    ))
+    assert not errors, "Type attribution errors:\n" + "\n".join(f"  - {e}" for e in errors)
+
+
+@requires_ty_cli
+def test_boolean_op_type_attribution():
+    """Verify that True and False has type Boolean."""
+    errors = []
+
+    def check_types(source_file):
+        assert isinstance(source_file, CompilationUnit)
+
+        class TypeChecker(PythonVisitor):
+            def visit_binary(self, binary, p):
+                if not isinstance(binary, Binary):
+                    return binary
+                if binary.operator != Binary.Type.And:
+                    return binary
+                if binary.type is None:
+                    errors.append("Binary(And).type is None")
+                elif binary.type != JavaType.Primitive.Boolean:
+                    errors.append(f"Binary(And).type is {binary.type}, expected Primitive.Boolean")
+                return binary
+
+        TypeChecker().visit(source_file, None)
+
+    # language=python
+    RecipeSpec(type_attribution=True).rewrite_run(python(
+        "x = True and False",
+        after_recipe=check_types,
+    ))
+    assert not errors, "Type attribution errors:\n" + "\n".join(f"  - {e}" for e in errors)

rewrite-python/rewrite/tests/python/all/tree/class_test.py

@@ -1,5 +1,18 @@
+import shutil
+
+import pytest
+
+from rewrite.java.support_types import JavaType
+from rewrite.java.tree import Assignment
+from rewrite.python.tree import CompilationUnit
+from rewrite.python.visitor import PythonVisitor
 from rewrite.test import RecipeSpec, python
 
+requires_ty_cli = pytest.mark.skipif(
+    shutil.which('ty-types') is None,
+    reason="ty-types CLI is not installed"
+)
+
 
 def test_empty():
     # language=python
@@ -110,3 +123,39 @@ class C3(Generic[T], metaclass=type, *[str]):
             ...
         """
     ))
+
+
+@requires_ty_cli
+def test_class_instance_type_attribution():
+    """Verify that x = Foo() assigns a type with fqn 'Foo'."""
+    errors = []
+
+    def check_types(source_file):
+        assert isinstance(source_file, CompilationUnit)
+
+        class TypeChecker(PythonVisitor):
+            def visit_assignment(self, assignment, p):
+                if not isinstance(assignment, Assignment):
+                    return assignment
+                if assignment.type is None:
+                    errors.append("Assignment.type is None for Foo()")
+                elif isinstance(assignment.type, JavaType.Class):
+                    if assignment.type._fully_qualified_name != 'Foo':
+                        errors.append(f"Assignment.type fqn is '{assignment.type._fully_qualified_name}', expected 'Foo'")
+                else:
+                    # Accept any non-None type
+                    pass
+                return assignment
+
+        TypeChecker().visit(source_file, None)
+
+    # language=python
+    RecipeSpec(type_attribution=True).rewrite_run(python(
+        """\
+        class Foo:
+            pass
+        x = Foo()
+        """,
+        after_recipe=check_types,
+    ))
+    assert not errors, "Type attribution errors:\n" + "\n".join(f"  - {e}" for e in errors)