Use moduleName from ty-types for module-qualified FQNs

classLiteral types now use moduleName to build proper FQNs
(e.g. mymodule.MyClass instead of bare MyClass), and bare
function calls get a declaring type from their module. Bumps
ty-types to 0.0.19.dev20260223122104.

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.19.dev20260223102528",  # Type inference CLI for Python type attribution
+    "ty-types>=0.0.19.dev20260223122104",  # 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/type_mapping.py

@@ -446,7 +446,12 @@ def _descriptor_to_java_type(self, descriptor: Dict[str, Any]) -> Optional[JavaT
 
         elif kind == 'classLiteral':
             class_name = descriptor.get('className', '')
-            class_type = self._create_class_type(class_name)
+            module_name = descriptor.get('moduleName')
+            if module_name and module_name != 'builtins':
+                fqn = f"{module_name}.{class_name}"
+            else:
+                fqn = class_name
+            class_type = self._create_class_type(fqn)
 
             # Infer Kind from supertypes before resolving them
             supertypes = descriptor.get('supertypes', [])
@@ -881,6 +886,10 @@ def _get_declaring_type(self, node: ast.Call) -> Optional[JavaType.FullyQualifie
                     kind = descriptor.get('kind')
                     if kind == 'module':
                         return self._create_class_type(descriptor.get('moduleName', ''))
+                    elif kind in ('function', 'boundMethod'):
+                        module_name = descriptor.get('moduleName')
+                        if module_name and module_name != 'builtins':
+                            return self._create_class_type(module_name)
 
         return self._infer_declaring_type_from_ast(node)
 

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

@@ -1,9 +1,12 @@
+import json
 import shutil
+import subprocess
+import tempfile
 
 import pytest
 
 from rewrite.java.support_types import JavaType
-from rewrite.java.tree import Assignment, Identifier
+from rewrite.java.tree import Assignment, ClassDeclaration, Identifier
 from rewrite.python.tree import CompilationUnit
 from rewrite.python.visitor import PythonVisitor
 from rewrite.test import RecipeSpec, python
@@ -14,6 +17,30 @@
 )
 
 
+def _ty_types_has_module_name() -> bool:
+    """Check if the installed ty-types CLI provides moduleName on classLiteral descriptors."""
+    if shutil.which('ty-types') is None:
+        return False
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+            f.write('class _C:\n    pass\n')
+            fname = f.name
+        result = subprocess.run(['ty-types', fname], capture_output=True, text=True, timeout=30)
+        data = json.loads(result.stdout)
+        return any(
+            d.get('kind') == 'classLiteral' and 'moduleName' in d
+            for d in data.get('types', {}).values()
+        )
+    except Exception:
+        return False
+
+
+requires_module_name = pytest.mark.skipif(
+    not _ty_types_has_module_name(),
+    reason="ty-types CLI does not provide moduleName on classLiteral descriptors"
+)
+
+
 def test_empty():
     # language=python
     RecipeSpec().rewrite_run(python(
@@ -174,6 +201,41 @@ def __init__(self, value: T) -> None:
     assert not errors, "Type attribution errors:\n" + "\n".join(f"  - {e}" for e in errors)
 
 
+@requires_module_name
+def test_class_literal_module_qualified_fqn():
+    """Verify that a class defined in a module gets a module-qualified FQN on its classLiteral type."""
+    errors = []
+
+    def check_types(source_file):
+        assert isinstance(source_file, CompilationUnit)
+
+        class TypeChecker(PythonVisitor):
+            def visit_class_declaration(self, class_decl, p):
+                if not isinstance(class_decl, ClassDeclaration):
+                    return class_decl
+                cd_type = class_decl.type
+                if cd_type is None:
+                    errors.append("ClassDeclaration.type is None for MyClass")
+                elif isinstance(cd_type, JavaType.Class):
+                    fqn = cd_type._fully_qualified_name
+                    # The FQN should contain a module prefix (not just bare 'MyClass')
+                    if '.' not in fqn:
+                        errors.append(f"ClassDeclaration.type fqn '{fqn}' has no module prefix, expected '<module>.MyClass'")
+                return class_decl
+
+        TypeChecker().visit(source_file, None)
+
+    # language=python
+    RecipeSpec(type_attribution=True).rewrite_run(python(
+        """\
+        class MyClass:
+            pass
+        """,
+        after_recipe=check_types,
+    ))
+    assert not errors, "Type attribution errors:\n" + "\n".join(f"  - {e}" for e in errors)
+
+
 @requires_ty_cli
 def test_class_instance_type_attribution():
     """Verify that x = Foo() assigns a type with fqn 'Foo'."""

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

@@ -139,7 +139,6 @@ def test_qualified_import_type_attribution():
 
 
 @requires_ty_cli
-@pytest.mark.xfail(reason="from-import direct calls do not yet populate declaring_type")
 def test_from_import_type_attribution():
     """from os import getcwd; getcwd() → declaring_type.fqn == 'os'."""
     errors = []

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

@@ -1,4 +1,7 @@
+import json
 import shutil
+import subprocess
+import tempfile
 
 import pytest
 
@@ -14,6 +17,30 @@
 )
 
 
+def _ty_types_has_module_name() -> bool:
+    """Check if the installed ty-types CLI provides moduleName on function descriptors."""
+    if shutil.which('ty-types') is None:
+        return False
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+            f.write('from os.path import join\njoin("a", "b")\n')
+            fname = f.name
+        result = subprocess.run(['ty-types', fname], capture_output=True, text=True, timeout=30)
+        data = json.loads(result.stdout)
+        return any(
+            d.get('kind') == 'function' and 'moduleName' in d
+            for d in data.get('types', {}).values()
+        )
+    except Exception:
+        return False
+
+
+requires_module_name = pytest.mark.skipif(
+    not _ty_types_has_module_name(),
+    reason="ty-types CLI does not provide moduleName on function descriptors"
+)
+
+
 def test_no_select():
     # language=python
     RecipeSpec().rewrite_run(python("assert len('a')"))
@@ -249,3 +276,43 @@ def identity[T](x: T) -> T:
         after_recipe=check_types,
     ))
     assert not errors, "Type attribution errors:\n" + "\n".join(f"  - {e}" for e in errors)
+
+
+@requires_module_name
+def test_bare_function_declaring_type_has_module():
+    """Verify that a bare function call imported from a module gets a declaring type with the module name."""
+    errors = []
+
+    def check_types(source_file):
+        assert isinstance(source_file, CompilationUnit)
+
+        class TypeChecker(PythonVisitor):
+            def visit_method_invocation(self, method, p):
+                if not isinstance(method, MethodInvocation):
+                    return method
+                if method.name.simple_name != 'join':
+                    return method
+                if method.method_type is None:
+                    errors.append("MethodInvocation.method_type is None for join()")
+                else:
+                    dt = method.method_type.declaring_type
+                    if dt is None:
+                        errors.append("method_type.declaring_type is None for join()")
+                    elif not hasattr(dt, '_fully_qualified_name') or 'posixpath' not in dt._fully_qualified_name:
+                        errors.append(
+                            f"declaring_type fqn is '{getattr(dt, '_fully_qualified_name', '?')}', "
+                            f"expected to contain 'posixpath' (os.path module)"
+                        )
+                return method
+
+        TypeChecker().visit(source_file, None)
+
+    # language=python
+    RecipeSpec(type_attribution=True).rewrite_run(python(
+        """\
+        from os.path import join
+        x = join("a", "b")
+        """,
+        after_recipe=check_types,
+    ))
+    assert not errors, "Type attribution errors:\n" + "\n".join(f"  - {e}" for e in errors)