Python: Upgrade ty to 0.0.17 and fix type errors (#6737)

* Python: Upgrade ty to 0.0.17 and fix type errors

Upgrade the ty type checker from 0.0.15 to 0.0.17, reducing diagnostics
from 92 to 33 by fixing real type errors and updating stale suppression
comments.

Changes:
- Bump ty>=0.0.15 to ty>=0.0.17 in pyproject.toml
- Update 4 stale `ty: ignore[possibly-missing-attribute]` to
  `ty: ignore[unresolved-attribute]` (rule renamed in 0.0.17)
- Add `invalid-method-override = "ignore"` for ~30 visitor pattern
  parameter name mismatches, remove 5 now-stale inline suppressions
- Fix 3 `invalid-parameter-default` errors: `Tree = None` to
  `Optional[Tree] = None` in format visitors
- Fix 5 format visitor `visit()` return types with proper cast
- Fix `_concatenate_prefix` parameter type `J` to `J2` to match return
- Remove 6 redundant casts in format visitors
- Add 5 asserts for potential None dereferences after `__convert()`
  and `visit_and_cast()` calls
- Extract `_callable_arg_count()` helper to avoid `__code__` access
  on union callable types
- Add inline `ty: ignore[unresolved-import]` for false positives
  (pytest, string.templatelib, PyComment, Markup types)

* Python: Fix invalid-method-override errors and remove global ignore

Rename visitor method parameters to match base class signatures and fix
type annotations so the global `invalid-method-override = "ignore"` in
pyproject.toml can be removed. Add targeted inline `ty: ignore` comments
only for the 3 cases where overrides intentionally narrow types.

Author: knutwannheden

rewrite-python/rewrite/pyproject.toml

@@ -36,7 +36,7 @@ dev = [
     "ruff>=0.1.0",
 ]
 typing = [
-    "ty>=0.0.15",  # Required for type attribution with Java recipes
+    "ty>=0.0.17",  # Required for type attribution with Java recipes
 ]
 publish = [
     "build>=1.0.0",

rewrite-python/rewrite/src/rewrite/__init__.py

@@ -2,7 +2,7 @@
 
 # helps pytest to rewrite the assert statements in test.py
 try:
-    import pytest
+    import pytest  # ty: ignore[unresolved-import]
     pytest.register_assert_rewrite("rewrite.test")
 except ImportError:
     pass  # pytest not available, skip assert rewriting

rewrite-python/rewrite/src/rewrite/parser.py

@@ -141,7 +141,7 @@ def with_erroneous(self, erroneous: Optional[SourceFile]) -> 'ParseError':
         return self if erroneous is self._erroneous else replace(self, _erroneous=erroneous)
 
     def printer(self, cursor: Cursor) -> TreeVisitor[Tree, PrintOutputCapture[P]]:
-        return PrinterFactory.current().create_printer(cursor)  # ty: ignore[possibly-missing-attribute]  # PrinterFactory.current() is always set
+        return PrinterFactory.current().create_printer(cursor)  # ty: ignore[unresolved-attribute]  # PrinterFactory.current() is always set
 
     def is_acceptable(self, v: TreeVisitor[Any, P], p: P) -> bool:
         return v.is_adaptable_to(ParseErrorVisitor)

rewrite-python/rewrite/src/rewrite/python/__init__.py

@@ -67,7 +67,7 @@
     VariableScope,
     YieldFrom,
 )
-from rewrite.python.support_types import PyComment
+from rewrite.python.support_types import PyComment  # ty: ignore[unresolved-import]
 from rewrite.python.visitor import PythonVisitor
 from rewrite.python.style import (
     SpacesStyle,

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

@@ -792,6 +792,7 @@ def visit_Import(self, node):
         if len(node.names) == 1:
             prefix = self.__source_before('import')
             imp = self.__convert(node.names[0])
+            assert imp is not None
             return imp.replace(prefix=prefix, qualid=imp.qualid.replace(prefix=imp.prefix))
 
         prefix = self.__source_before('import')
@@ -1705,6 +1706,7 @@ def visit_BinOp(self, node):
     def visit_BoolOp(self, node):
         prefix = self.__whitespace()
         left = self.__convert(node.values[0])
+        assert left is not None
         for right_expr in node.values[1:]:
             left = j.Binary(
                 random_id(),
@@ -2246,7 +2248,7 @@ def __map_decorator(self, decorator) -> j.Annotation:
         # Wrap name in extra parentheses if present
         if extra_parens:
             # Set the inner prefix on the name
-            name = name.replace(prefix=extra_parens[-1][1])  # ty: ignore[possibly-missing-attribute]  # recursive call returns unknown
+            name = name.replace(prefix=extra_parens[-1][1])  # ty: ignore[unresolved-attribute]  # recursive call returns unknown
 
             # Wrap in extra parentheses (innermost to outermost)
             wrapped: Expression = name
@@ -2731,7 +2733,7 @@ def visit_Tuple(self, node):
             extra_parens[0][1] if extra_parens else prefix,
             Markers.EMPTY,
             py.CollectionLiteral.Kind.TUPLE,
-            elements.replace(markers=  # ty: ignore[possibly-missing-attribute]  # complex union type
+            elements.replace(markers=  # ty: ignore[unresolved-attribute]  # complex union type
                 Markers.build(random_id(), [OmitParentheses(random_id())])) if omit_parens else elements,
             self._type_mapping.type(node)
         )
@@ -3322,6 +3324,7 @@ def __map_fstring_as_literal(self, node: ast.JoinedStr, leading_prefix: Space, t
                     self._type_mapping.type(node)
                 )
             is_first = False
+        assert res is not None
         return res
 
     def __map_fstring(self, node, prefix: Space, tok: TokenInfo, value_idx: int = 0, *,

rewrite-python/rewrite/src/rewrite/python/format/blank_lines.py

@@ -11,23 +11,23 @@
 
 
 class BlankLinesVisitor(PythonVisitor):
-    def __init__(self, style: BlankLinesStyle, stop_after: Tree = None):
+    def __init__(self, style: BlankLinesStyle, stop_after: Optional[Tree] = None):
         self._style = style
         self._stop_after = stop_after
         self._stop = False
 
-    def visit_compilation_unit(self, compilation_unit: CompilationUnit, p: P) -> J:
-        if not compilation_unit.prefix.comments:
-            compilation_unit = compilation_unit.replace(prefix=Space.EMPTY)
-        return super().visit_compilation_unit(compilation_unit, p)
+    def visit_compilation_unit(self, cu: CompilationUnit, p: P) -> J:
+        if not cu.prefix.comments:
+            cu = cu.replace(prefix=Space.EMPTY)
+        return super().visit_compilation_unit(cu, p)
 
-    def visit_statement(self, statement: Statement, p: P) -> J:
-        statement = super().visit_statement(statement, p)
+    def visit_statement(self, stmt: Statement, p: P) -> J:
+        stmt = super().visit_statement(stmt, p)
 
         parent_cursor = self.cursor.parent_tree_cursor()
         top_level = isinstance(parent_cursor.value, CompilationUnit)
 
-        if isinstance(statement, (Import, MultiImport)):
+        if isinstance(stmt, (Import, MultiImport)):
             parent_cursor.put_message('prev_import', True)
             prev_import = False
         else:
@@ -36,43 +36,43 @@ def visit_statement(self, statement: Statement, p: P) -> J:
                 parent_cursor.put_message('prev_import', False)
 
         if top_level:
-            if statement == cast(CompilationUnit, parent_cursor.value).statements[0]:
-                statement = statement.replace(prefix=statement.prefix.replace(whitespace=''))
+            if stmt == cast(CompilationUnit, parent_cursor.value).statements[0]:
+                stmt = stmt.replace(prefix=stmt.prefix.replace(whitespace=''))
             else:
-                min_lines = max(self._style.minimum.around_top_level_classes_functions if isinstance(statement, (ClassDeclaration, MethodDeclaration)) else 0,
+                min_lines = max(self._style.minimum.around_top_level_classes_functions if isinstance(stmt, (ClassDeclaration, MethodDeclaration)) else 0,
                                 self._style.minimum.after_top_level_imports if prev_import else 0)
-                statement = _adjusted_lines_for_tree(statement, min_lines, self._style.keep_maximum.in_declarations)
+                stmt = _adjusted_lines_for_tree(stmt, min_lines, self._style.keep_maximum.in_declarations)
         else:
             in_block = isinstance(parent_cursor.value, Block)
             in_class = in_block and isinstance(parent_cursor.parent_tree_cursor().value, ClassDeclaration)
             min_lines = 0
             if in_class:
-                is_first = cast(Block, parent_cursor.value).statements[0] is statement
-                if not is_first and isinstance(statement, MethodDeclaration):
+                is_first = cast(Block, parent_cursor.value).statements[0] is stmt
+                if not is_first and isinstance(stmt, MethodDeclaration):
                     min_lines = max(min_lines, self._style.minimum.around_method)
-                elif not is_first and isinstance(statement, ClassDeclaration):
+                elif not is_first and isinstance(stmt, ClassDeclaration):
                     min_lines = max(min_lines, self._style.minimum.around_class)
-                elif is_first and isinstance(statement, MethodDeclaration):
+                elif is_first and isinstance(stmt, MethodDeclaration):
                     min_lines = max(min_lines, self._style.minimum.before_first_method)
 
             # This seems to correspond to how IntelliJ interprets this configuration
             max_lines = self._style.keep_maximum.in_declarations if \
-                isinstance(statement, (ClassDeclaration, MethodDeclaration)) else \
+                isinstance(stmt, (ClassDeclaration, MethodDeclaration)) else \
                 self._style.keep_maximum.in_code
 
             if prev_import:
                 min_lines = max(min_lines, self._style.minimum.after_local_imports)
 
-            statement = _adjusted_lines_for_tree(statement, min_lines, max_lines)
-        return statement
+            stmt = _adjusted_lines_for_tree(stmt, min_lines, max_lines)
+        return stmt
 
     def post_visit(self, tree: T, p: P) -> Optional[T]:
         if self._stop_after and tree == self._stop_after:
             self._stop = True
         return tree
 
     def visit(self, tree: Optional[Tree], p: P, parent: Optional[Cursor] = None) -> Optional[T]:
-        return tree if self._stop else super().visit(tree, p, parent)
+        return cast(Optional[T], tree if self._stop else super().visit(tree, p, parent))
 
 
 def _adjusted_lines_for_right_padded(tree: JRightPadded[J2], min_lines: int, max_lines: int) -> JRightPadded[J2]:

rewrite-python/rewrite/src/rewrite/python/format/minimum_viable_spacing.py

@@ -33,7 +33,7 @@ def post_visit(self, tree: T, p: P) -> Optional[T]:
         return tree
 
     def visit(self, tree: Optional[Tree], p: P, parent: Optional[Cursor] = None) -> Optional[T]:
-        return tree if self._stop else super().visit(tree, p, parent)
+        return cast(Optional[T], tree if self._stop else super().visit(tree, p, parent))
 
 
 def _common_margin(s1, s2):

rewrite-python/rewrite/src/rewrite/python/format/normalize_format.py

@@ -11,12 +11,12 @@
 
 
 class NormalizeFormatVisitor(PythonVisitor):
-    def __init__(self, stop_after: Tree = None):
+    def __init__(self, stop_after: Optional[Tree] = None):
         self._stop_after = stop_after
         self._stop = False
 
-    def visit_class_declaration(self, cd: ClassDeclaration, p: P) -> J:
-        cd = cast(ClassDeclaration, super().visit_class_declaration(cd, p))
+    def visit_class_declaration(self, class_decl: ClassDeclaration, p: P) -> J:
+        cd = cast(ClassDeclaration, super().visit_class_declaration(class_decl, p))
         if cd.leading_annotations:
             cd = _concatenate_prefix(cd, Space.first_prefix(cd.leading_annotations))
             cd = cd.replace(leading_annotations=Space.format_first_prefix(cd.leading_annotations, Space.EMPTY))
@@ -26,8 +26,8 @@ def visit_class_declaration(self, cd: ClassDeclaration, p: P) -> J:
         cd = cd.padding.replace(kind=cd.padding.kind.with_prefix(Space.EMPTY))
         return cd
 
-    def visit_method_declaration(self, md: MethodDeclaration, p: P) -> J:
-        md = cast(MethodDeclaration, super().visit_method_declaration(md, p))
+    def visit_method_declaration(self, method: MethodDeclaration, p: P) -> J:
+        md = cast(MethodDeclaration, super().visit_method_declaration(method, p))
         if md.leading_annotations:
             md = _concatenate_prefix(md, Space.first_prefix(md.leading_annotations))
             md = md.replace(leading_annotations=Space.format_first_prefix(md.leading_annotations, Space.EMPTY))
@@ -46,7 +46,7 @@ def post_visit(self, tree: T, p: P) -> Optional[T]:
         return tree
 
     def visit(self, tree: Optional[Tree], p: P, parent: Optional[Cursor] = None) -> Optional[T]:
-        return tree if self._stop else super().visit(tree, p, parent)
+        return cast(Optional[T], tree if self._stop else super().visit(tree, p, parent))
 
 
 def _common_margin(s1, s2):
@@ -62,7 +62,7 @@ def _common_margin(s1, s2):
     return s2 if len(s2) < len(s1) else s1
 
 
-def _concatenate_prefix(j: J, prefix: Space) -> J2:
+def _concatenate_prefix(j: J2, prefix: Space) -> J2:
     if prefix.is_empty():
         return j
 

rewrite-python/rewrite/src/rewrite/python/format/normalize_line_breaks_visitor.py

@@ -34,7 +34,7 @@ def process_comment(comment: Comment) -> Comment:
 
         return s.replace(comments=list_map(process_comment, s.comments))
 
-    def post_visit(self, tree: T, _: object) -> Optional[T]:
+    def post_visit(self, tree: T, p: P) -> Optional[T]:
         if self._stop_after and tree == self._stop_after:
             self._stop = True
         return tree

rewrite-python/rewrite/src/rewrite/python/format/normalize_tabs_or_spaces.py

@@ -13,12 +13,12 @@
 # TODO consider supporting multiline string literals
 class NormalizeTabsOrSpacesVisitor(PythonVisitor):
 
-    def __init__(self, style: TabsAndIndentsStyle, stop_after: Tree = None):
+    def __init__(self, style: TabsAndIndentsStyle, stop_after: Optional[Tree] = None):
         self._stop_after = stop_after
         self._style = style
         self._stop = False
 
-    def visit_space(self, space: Space, p):
+    def visit_space(self, space: Optional[Space], p):
         if not space or space is Space.EMPTY:
             return space
 
@@ -81,4 +81,4 @@ def post_visit(self, tree: T, p: P) -> Optional[T]:
         return tree
 
     def visit(self, tree: Optional[Tree], p: P, parent: Optional[Cursor] = None) -> Optional[T]:
-        return tree if self._stop else super().visit(tree, p, parent)
+        return cast(Optional[T], tree if self._stop else super().visit(tree, p, parent))