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

@@ -82,11 +82,8 @@ include = ["src"]
 # - invalid-argument-type: ~200 errors from Self type vs concrete type in accept_*() methods
 #   (tracked as ty bug: https://github.com/astral-sh/ty/issues/2255)
 # - unresolved-reference: TYPE_CHECKING forward references
-# - invalid-method-override: ~30 errors from visitor pattern parameter name mismatches
-#   (e.g. visit_compilation_unit(cu) vs visit_compilation_unit(compilation_unit))
 invalid-argument-type = "ignore"
 unresolved-reference = "ignore"
-invalid-method-override = "ignore"
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

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

@@ -16,18 +16,18 @@ def __init__(self, style: BlankLinesStyle, stop_after: Optional[Tree] = None):
         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,35 +36,35 @@ 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:

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

@@ -15,8 +15,8 @@ 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))

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

@@ -18,7 +18,7 @@ def __init__(self, style: TabsAndIndentsStyle, stop_after: Optional[Tree] = None
         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
 

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

@@ -12,10 +12,10 @@ def __init__(self, stop_after: Optional[Tree] = None):
         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)
-        cu: j.CompilationUnit = cast(j.CompilationUnit, 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)
+        cu: j.CompilationUnit = cast(j.CompilationUnit, super().visit_compilation_unit(cu, p))
 
         if cu.eof.whitespace:
             clean = "".join([_ for _ in cu.eof.whitespace if _ in ['\n', '\r']])