openrewrite-migrate-python 0.14.0.dev20260902105951__tar.gz → 0.14.0.dev20260902123950__tar.gz

{openrewrite_migrate_python-0.14.0.dev20260902105951 → openrewrite_migrate_python-0.14.0.dev20260902123950}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.14.0.dev20260902105951
+Version: 0.14.0.dev20260902123950
 Summary: OpenRewrite recipes for migrating Python codebases to newer Python versions.
 Author-email: "Moderne Inc." <support@moderne.io>
 License: Moderne Proprietary

{openrewrite_migrate_python-0.14.0.dev20260902105951 → openrewrite_migrate_python-0.14.0.dev20260902123950}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "openrewrite-migrate-python"
 description = "OpenRewrite recipes for migrating Python codebases to newer Python versions."
-version = "0.14.0.dev20260902105951"  # Updated dynamically during release
+version = "0.14.0.dev20260902123950"  # Updated dynamically during release
 authors = [{ name = "Moderne Inc.", email = "support@moderne.io" }]
 license = { text = "Moderne Proprietary" }
 readme = "README.md"

openrewrite_migrate_python-0.14.0.dev20260902123950/src/openrewrite_code_quality_python/codequality/remove_self_assignment.py

@@ -0,0 +1,275 @@
+"""
+Recipe to remove self-assignments.
+
+Assigning a plain local name to itself (``x = x``) has no effect and is
+almost always a copy-paste error or leftover from a refactoring.
+Removing these statements makes the code cleaner and avoids
+confusion about the author's intent.
+
+See: https://rules.sonarsource.com/python/RSPEC-S1656/
+"""
+
+from itertools import islice
+from typing import Any, List, Optional, Tuple
+
+from rewrite import Cursor, ExecutionContext, Recipe, TreeVisitor
+from rewrite.category import CategoryDescriptor
+from rewrite.decorators import categorize
+from rewrite.marketplace import Python
+from rewrite.python.tree import CompilationUnit
+from rewrite.python.visitor import PythonVisitor
+from rewrite.java.support_types import Space
+from rewrite.java.tree import (
+    Assignment,
+    Block,
+    ClassDeclaration,
+    Identifier,
+    If,
+    MethodDeclaration,
+    Statement,
+)
+
+_CodeQuality = [
+    *Python,
+    CategoryDescriptor(display_name="Code quality"),
+]
+
+
+def _is_local_self_assignment(statement: Statement) -> bool:
+    """Return True for ``x = x`` on a plain name.
+
+    Only a plain name is a no-op.  ``obj.x = obj.x`` and ``d[k] = d[k]``
+    read *and* write through ``__set__``/``__setitem__``, and the other
+    assignment shapes (``x: int = x``, ``x = y = y``, ``x += x``) parse to
+    node types this deliberately does not match.
+    """
+    if not isinstance(statement, Assignment):
+        return False
+    target, value = statement.variable, statement.assignment
+    return (
+        isinstance(target, Identifier)
+        and isinstance(value, Identifier)
+        and target.simple_name == value.simple_name
+    )
+
+
+def _in_function_scope(cursor: Cursor) -> bool:
+    """Return True when the block at ``cursor`` belongs to a function.
+
+    ``X = X`` is a no-op only where both sides bind the same name.  In a
+    class body or at module scope the right-hand side reads an enclosing
+    binding while the left-hand side creates a new one, so the statement
+    is what publishes the name.
+    """
+    for value in islice(cursor.get_path(), 1, None):
+        if isinstance(value, MethodDeclaration):
+            return True
+        if isinstance(value, (ClassDeclaration, CompilationUnit)):
+            return False
+    return False
+
+
+def _space_after_block(cursor: Cursor) -> Optional[Space]:
+    """The trivia the printer emits after the block at ``cursor``.
+
+    A statement's trailing comment is stored on whatever follows it, so a
+    block's last statement keeps its comment outside the block -- on the
+    next statement of an enclosing block, on the `else` of an enclosing
+    `if`, or at end of file.  Returns None for the containers this does not
+    know how to look past.
+    """
+    child = cursor.value
+    for parent in islice(cursor.get_path(), 1, None):
+        if isinstance(parent, (Block, CompilationUnit)):
+            statements = parent._statements
+            index = next(
+                (i for i, s in enumerate(statements) if s.element.id == child.id),
+                None,
+            )
+            if index is None:
+                return None
+            if index + 1 < len(statements):
+                return statements[index + 1].element.prefix
+            if isinstance(parent, CompilationUnit):
+                return parent.eof
+        elif isinstance(parent, If):
+            if parent.else_part is not None and parent.else_part.id != child.id:
+                return parent.else_part.prefix
+        elif not isinstance(parent, (ClassDeclaration, If.Else, MethodDeclaration)):
+            return None
+        child = parent
+    return None
+
+
+def _ends_line_with_comment(space: Space) -> bool:
+    """Return True when ``space`` opens with a comment on the line it continues."""
+    split = _split_line(space)
+    return bool((split[0] if split else space).comments)
+
+
+def _split_line(space: Space) -> Optional[Tuple[Space, Space]]:
+    """Split ``space`` at its first newline, or return None if it has no newline.
+
+    The head is the trivia that still belongs to the preceding line -- most
+    importantly that line's trailing comment.  The tail starts with the
+    newline itself.
+    """
+    newline = space.whitespace.find("\n")
+    if newline != -1:
+        return (
+            Space(_comments=[], _whitespace=space.whitespace[:newline]),
+            Space(_comments=space.comments, _whitespace=space.whitespace[newline:]),
+        )
+    for i, comment in enumerate(space.comments):
+        newline = comment.suffix.find("\n")
+        if newline != -1:
+            return (
+                Space(
+                    _comments=[
+                        *space.comments[:i],
+                        comment.replace(_suffix=comment.suffix[:newline]),
+                    ],
+                    _whitespace=space.whitespace,
+                ),
+                Space(
+                    _comments=space.comments[i + 1:],
+                    _whitespace=comment.suffix[newline:],
+                ),
+            )
+    return None
+
+
+def _concat(left: Space, right: Space) -> Space:
+    """Return the trivia that prints as ``left`` followed by ``right``."""
+    if not left.comments:
+        return Space(
+            _comments=right.comments,
+            _whitespace=left.whitespace + right.whitespace,
+        )
+    last = left.comments[-1]
+    return Space(
+        _comments=[
+            *left.comments[:-1],
+            last.replace(_suffix=last.suffix + right.whitespace),
+            *right.comments,
+        ],
+        _whitespace=left.whitespace,
+    )
+
+
+def _removable(padded_statements: list, i: int, space_after_block: Optional[Space]) -> bool:
+    """Return True when statement ``i`` can be dropped without disturbing its neighbours.
+
+    The removal is expressed by splicing line-level trivia, so the statement
+    has to occupy a line of its own, and so does whatever the printer emits
+    next -- either the following statement or, for the last one, the trivia
+    after the block.  A last statement whose line ends in a comment stays:
+    that comment is held outside the block, out of reach.
+    """
+    if not _is_local_self_assignment(padded_statements[i].element):
+        return False
+    if _split_line(padded_statements[i].element.prefix) is None:
+        return False
+    if i + 1 < len(padded_statements):
+        return _split_line(padded_statements[i + 1].element.prefix) is not None
+    return space_after_block is not None and not _ends_line_with_comment(space_after_block)
+
+
+def _remove_self_assignments(
+    padded_statements: list, end: Space, space_after_block: Optional[Space]
+) -> Optional[Tuple[list, Space]]:
+    """Return the block's statements and end trivia with self-assignments removed, or None if unchanged.
+
+    Each removed statement's leading trivia is kept up to its own line (it
+    holds the preceding statement's trailing comment) and its successor's is
+    dropped up to the same point (it holds the removed statement's own).
+    Emptying a block would leave its header without a body, so the last
+    surviving statement stays.
+    """
+    to_remove = {
+        i
+        for i in range(len(padded_statements))
+        if _removable(padded_statements, i, space_after_block)
+    }
+    if not to_remove or len(to_remove) == len(padded_statements):
+        return None
+
+    result = []
+    pending_head: Optional[Space] = None
+    for i, padded in enumerate(padded_statements):
+        if i in to_remove:
+            if pending_head is None:
+                pending_head, _ = _split_line(padded.element.prefix)
+            continue
+        if pending_head is not None:
+            _, tail = _split_line(padded.element.prefix)
+            padded = padded.replace(
+                _element=padded.element.replace(
+                    _prefix=_concat(pending_head, tail)
+                )
+            )
+            pending_head = None
+        result.append(padded)
+    return result, end if pending_head is None else _concat(pending_head, end)
+
+
+@categorize(_CodeQuality)
+class RemoveSelfAssignment(Recipe):
+    """
+    Remove assignments of a plain local name to itself.
+
+    A self-assignment like ``x = x`` inside a function does nothing at
+    runtime.  These statements typically result from copy-paste mistakes
+    or incomplete refactorings and should be deleted to keep the code
+    clear.
+
+    Example:
+        Before:
+            x = x
+
+        After:
+            (statement removed)
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.codequality.RemoveSelfAssignment"
+
+    @property
+    def display_name(self) -> str:
+        return "Remove self-assignments"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Remove statements inside a function that assign a plain local name "
+            "to itself (`x = x`), since they have no effect. Class-body and "
+            "module-level `X = X` bind a new name from an enclosing one and are "
+            "left alone, as are attribute and subscript targets, which run "
+            "`__set__` and `__setitem__`."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "code-quality", "RSPEC-S1656"]
+
+    @property
+    def estimated_effort_per_occurrence(self) -> int:
+        return 3
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_block(
+                self, block: Block, p: ExecutionContext
+            ) -> Optional[Block]:
+                block = super().visit_block(block, p)
+                if not isinstance(block, Block) or not _in_function_scope(self.cursor):
+                    return block
+                removed = _remove_self_assignments(
+                    block._statements, block.end, _space_after_block(self.cursor)
+                )
+                if removed is not None:
+                    return block.replace(_statements=removed[0], _end=removed[1])
+                return block
+
+        return Visitor()