openrewrite-migrate-python 0.15.1__tar.gz → 0.15.2__tar.gz

{openrewrite_migrate_python-0.15.1 → openrewrite_migrate_python-0.15.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.15.1
+Version: 0.15.2
 Summary: OpenRewrite recipes for migrating Python codebases to newer Python versions.
 Author-email: "Moderne Inc." <support@moderne.io>
 License: Moderne Proprietary
@@ -19,7 +19,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Provides-Extra: dev
-Requires-Dist: openrewrite>=8.92.3; extra == "dev"
+Requires-Dist: openrewrite>=8.92.18; extra == "dev"
 Requires-Dist: pydantic>=2.11; extra == "dev"
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

{openrewrite_migrate_python-0.15.1 → openrewrite_migrate_python-0.15.2}/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.15.1"  # Updated dynamically during release
+version = "0.15.2"  # Updated dynamically during release
 authors = [{ name = "Moderne Inc.", email = "support@moderne.io" }]
 license = { text = "Moderne Proprietary" }
 readme = "README.md"
@@ -28,7 +28,7 @@ dependencies = []
 
 [project.optional-dependencies]
 dev = [
-    "openrewrite>=8.92.3",
+    "openrewrite>=8.92.18",
     # Needed so type-attribution tests can resolve `pydantic` types.
     "pydantic>=2.11",
     "pytest>=8.0.0",

{openrewrite_migrate_python-0.15.1 → openrewrite_migrate_python-0.15.2}/src/openrewrite_code_quality_python/codequality/_reindent.py

@@ -4,12 +4,15 @@ Python indentation lives in the ``Space`` before each token, so moving a block
 to a shallower nesting level means rewriting every line it spans.
 """
 
-from typing import Optional, TypeVar
+from typing import Optional, TypeVar, cast
 
+from rewrite.java.markers import TrailingComma
 from rewrite.java.support_types import Space
+from rewrite.java.tree import J
+from rewrite.markers import Marker
 from rewrite.python.visitor import PythonVisitor
 
-T = TypeVar("T")
+T = TypeVar("T", bound=J)
 
 
 def inherited_prefix(dropped: Space, body: Space) -> Space:
@@ -65,6 +68,20 @@ class _Reindent(PythonVisitor[None]):
             return space
         return Space(_comments=comments, _whitespace=whitespace)
 
+    def visit_marker(self, marker: Marker, p: None) -> Marker:
+        # The line break before the bracket closing a trailing-comma list
+        # lives on the comma.
+        if isinstance(marker, TrailingComma):
+            suffix = self.visit_space(marker.suffix, p)
+            if suffix is not marker.suffix:
+                return marker.replace(_suffix=suffix)
+        return marker
+
+
+def reindent_space(space: Space, old_base: str, new_base: str) -> Space:
+    """:func:`reindent` for trivia that has no tree to travel with."""
+    return _Reindent(old_base, new_base).visit_space(space, None)
+
 
 def reindent(tree: T, old_base: str, new_base: str) -> T:
     """Re-base every line in *tree* that is indented at least to *old_base*.
@@ -74,4 +91,4 @@ def reindent(tree: T, old_base: str, new_base: str) -> T:
     """
     if old_base == new_base:
         return tree
-    return _Reindent(old_base, new_base).visit(tree, None)
+    return cast(T, _Reindent(old_base, new_base).visit(tree, None))

openrewrite_migrate_python-0.15.2/src/openrewrite_code_quality_python/codequality/_semantically_equal.py

@@ -0,0 +1,38 @@
+"""Semantic equality of LST nodes, for recipes that keep one of two equal subtrees."""
+
+from typing import List, Optional
+
+from rewrite.java.support_types import J, Space
+from rewrite.python.template.comparator import PythonComparatorVisitor
+from rewrite.python.visitor import PythonVisitor
+from rewrite.visitor import Cursor
+
+
+class _CommentTexts(PythonVisitor[List[str]]):
+    def visit_space(self, space: Optional[Space], p: List[str]) -> Space:
+        if space is not None:
+            p.extend(comment.text for comment in space.comments)
+        return super().visit_space(space, p)
+
+
+def _comment_texts(tree: J) -> List[str]:
+    texts: List[str] = []
+    _CommentTexts().visit(tree, texts)
+    return texts
+
+
+class SemanticallyEqual:
+    """Compare two LST nodes for structural equality."""
+
+    @staticmethod
+    def are_equal(a: Optional[J], b: Optional[J]) -> bool:
+        """Whether *a* and *b* are the same code carrying the same comments.
+
+        Whitespace is ignored. Comments must match, so a recipe dropping either copy loses none.
+        """
+        if a is None or b is None:
+            return a is b
+        return (
+            PythonComparatorVisitor().compare(a, b, Cursor(None, Cursor.ROOT_VALUE))
+            and _comment_texts(a) == _comment_texts(b)
+        )

openrewrite_migrate_python-0.15.2/src/openrewrite_code_quality_python/codequality/_side_effects.py

@@ -0,0 +1,36 @@
+from rewrite.java.tree import (
+    Binary as JBinary,
+    Expression,
+    FieldAccess,
+    Identifier,
+    Literal,
+    Parentheses,
+    Ternary,
+    Unary,
+)
+from rewrite.python.tree import Binary as PyBinary
+
+
+def is_side_effect_free(expr: Expression) -> bool:
+    """Whether evaluating ``expr`` is taken to have no side effects.
+
+    Names, literals, attribute reads and operators over them are taken as pure.
+    A call, subscript, walrus, ``await`` or any other node may run code that matters.
+    """
+    if isinstance(expr, (Identifier, Literal)):
+        return True
+    if isinstance(expr, FieldAccess):
+        return is_side_effect_free(expr.target)
+    if isinstance(expr, Parentheses):
+        return isinstance(expr.tree, Expression) and is_side_effect_free(expr.tree)
+    if isinstance(expr, Unary):
+        return is_side_effect_free(expr.expression)
+    if isinstance(expr, (JBinary, PyBinary)):
+        return is_side_effect_free(expr.left) and is_side_effect_free(expr.right)
+    if isinstance(expr, Ternary):
+        return (
+            is_side_effect_free(expr.condition)
+            and is_side_effect_free(expr.true_part)
+            and is_side_effect_free(expr.false_part)
+        )
+    return False

{openrewrite_migrate_python-0.15.1 → openrewrite_migrate_python-0.15.2}/src/openrewrite_code_quality_python/codequality/_trivia.py

@@ -12,7 +12,7 @@ from typing import Optional, Tuple
 
 from rewrite import Cursor
 from rewrite.java.support_types import Space
-from rewrite.java.tree import Block, ClassDeclaration, If, MethodDeclaration
+from rewrite.java.tree import Block, ClassDeclaration, If, J, MethodDeclaration
 from rewrite.python.tree import CompilationUnit
 
 
@@ -81,9 +81,11 @@ def space_after_block(cursor: Cursor) -> Optional[Space]:
     know how to look past.
     """
     child = cursor.value
+    if not isinstance(child, J):
+        return None
     for parent in islice(cursor.get_path(), 1, None):
         if isinstance(parent, (Block, CompilationUnit)):
-            statements = parent._statements
+            statements = parent.padding.statements
             index = next(
                 (i for i, s in enumerate(statements) if s.element.id == child.id),
                 None,
@@ -125,7 +127,8 @@ def splice_out(
             continue
         if pending is not None:
             head, line = pending
-            _, tail = split_line(padded.element.prefix)
+            prefix = padded.element.prefix
+            _, tail = split_line(prefix) or (Space.EMPTY, prefix)
             padded = padded.replace(
                 _element=padded.element.replace(
                     _prefix=concat(

{openrewrite_migrate_python-0.15.1 → openrewrite_migrate_python-0.15.2}/src/openrewrite_code_quality_python/codequality/all_branches_identical.py

@@ -15,7 +15,9 @@ from rewrite import 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.tree import J
 from rewrite.java.tree import (
     Block,
     If,
@@ -27,6 +29,7 @@ from openrewrite_code_quality_python.codequality._reindent import (
     reindent,
 )
 from openrewrite_code_quality_python.codequality._semantically_equal import SemanticallyEqual
+from openrewrite_code_quality_python.codequality._side_effects import is_side_effect_free
 
 _CodeQuality = [
     *Python,
@@ -68,6 +71,17 @@ def _collect_bodies(if_: If) -> list[Statement]:
     return bodies
 
 
+def _conditions_side_effect_free(if_: If) -> bool:
+    current = if_
+    while True:
+        if not is_side_effect_free(current.if_condition.tree):
+            return False
+        else_part = current.else_part
+        if else_part is None or not isinstance(else_part.body, If):
+            return True
+        current = else_part.body
+
+
 def _all_bodies_equal(bodies: list[Statement]) -> bool:
     """Return True when every body is semantically equal to the first."""
     if len(bodies) < 2:
@@ -90,7 +104,8 @@ class AllBranchesIdentical(Recipe):
     and eliminates a source of confusion for future readers.
 
     Only applies when the chain has an explicit ``else`` so that the
-    branches truly cover all cases.
+    branches truly cover all cases, and when no condition may have a
+    side effect that removing it would lose.
 
     Example:
         Before:
@@ -116,7 +131,8 @@ class AllBranchesIdentical(Recipe):
         return (
             "Replace `if`/`elif`/`else` chains where every branch has "
             "the same body with just the body, since the condition has "
-            "no effect on what code executes."
+            "no effect on what code executes. A chain whose conditions may "
+            "have side effects, such as a call, is left alone."
         )
 
     @property
@@ -130,19 +146,23 @@ class AllBranchesIdentical(Recipe):
     def editor(self) -> TreeVisitor[Any, ExecutionContext]:
         class Visitor(PythonVisitor[ExecutionContext]):
             def visit_compilation_unit(self, cu, p):
-                cu = super().visit_compilation_unit(cu, p)
-                new_stmts = _replace_identical_ifs_padded(cu._statements)
+                visited = super().visit_compilation_unit(cu, p)
+                if not isinstance(visited, CompilationUnit):
+                    return visited
+                cu = visited
+                new_stmts = _replace_identical_ifs_padded(cu.padding.statements)
                 if new_stmts is not None:
                     return cu.replace(_statements=new_stmts)
                 return cu
 
             def visit_block(
                 self, block: Block, p: ExecutionContext
-            ) -> Optional[Block]:
-                block = super().visit_block(block, p)
-                if not isinstance(block, Block):
-                    return block
-                new_stmts = _replace_identical_ifs_padded(block._statements)
+            ) -> J:
+                visited = super().visit_block(block, p)
+                if not isinstance(visited, Block):
+                    return visited
+                block = visited
+                new_stmts = _replace_identical_ifs_padded(block.padding.statements)
                 if new_stmts is not None:
                     return block.replace(_statements=new_stmts)
                 return block
@@ -163,7 +183,7 @@ def _replace_identical_ifs_padded(padded_stmts) -> Optional[list]:
         if not isinstance(s, If):
             result.append(rp)
             continue
-        if not _has_explicit_else(s):
+        if not _has_explicit_else(s) or not _conditions_side_effect_free(s):
             result.append(rp)
             continue
         bodies = _collect_bodies(s)
@@ -172,12 +192,12 @@ def _replace_identical_ifs_padded(padded_stmts) -> Optional[list]:
             continue
 
         body = s.then_part
-        if not isinstance(body, Block) or not body._statements:
+        if not isinstance(body, Block) or not body.padding.statements:
             result.append(rp)
             continue
 
         if_indent = line_indent(s.prefix)
-        body_indent = line_indent(body._statements[0].element.prefix)
+        body_indent = line_indent(body.padding.statements[0].element.prefix)
         if (
             if_indent is None
             or body_indent is None
@@ -187,7 +207,7 @@ def _replace_identical_ifs_padded(padded_stmts) -> Optional[list]:
             continue
 
         body = reindent(body, body_indent, if_indent)
-        first = body._statements[0]
+        first = body.padding.statements[0]
         # Each lifted statement keeps its own padding, which is where a `;`
         # separating it from the next one is recorded.
         result.append(
@@ -197,7 +217,7 @@ def _replace_identical_ifs_padded(padded_stmts) -> Optional[list]:
                 )
             )
         )
-        result.extend(body._statements[1:])
+        result.extend(body.padding.statements[1:])
         changed = True
 
     if not changed:

{openrewrite_migrate_python-0.15.1 → openrewrite_migrate_python-0.15.2}/src/openrewrite_code_quality_python/codequality/boolean_checks_not_inverted.py

@@ -8,18 +8,23 @@ when written as ``a != b``, and ``not (not x)`` is just ``x``.
 See: https://rules.sonarsource.com/python/RSPEC-S1940/
 """
 
-from typing import Any, List, Optional
+from typing import Any, List
 
-from rewrite import ExecutionContext, Recipe, TreeVisitor
+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 Binary as PyBinary
 from rewrite.python.visitor import PythonVisitor
-from rewrite.java.support_types import JLeftPadded, Space
+from rewrite.java.tree import J
+from rewrite.java.support_types import JavaType, JLeftPadded
 from rewrite.java.tree import (
+    Assert,
     Binary as JBinary,
+    ControlParentheses,
     Expression,
     Parentheses,
+    Ternary,
     Unary,
 )
 
@@ -37,6 +42,59 @@ _OPERATOR_INVERSE = {
     JBinary.Type.GreaterThanOrEqual: JBinary.Type.LessThan,
 }
 
+_EQUALITY = {JBinary.Type.Equal, JBinary.Type.NotEqual}
+
+_COMPARISONS = {
+    *_OPERATOR_INVERSE,
+    PyBinary.Type.In,
+    PyBinary.Type.NotIn,
+    PyBinary.Type.Is,
+    PyBinary.Type.IsNot,
+}
+
+_NUMERIC = {
+    JavaType.Primitive.Boolean,
+    JavaType.Primitive.Int,
+    JavaType.Primitive.Long,
+    JavaType.Primitive.Double,
+    JavaType.Primitive.Float,
+}
+
+
+def _is_comparison(expr: Expression) -> bool:
+    return isinstance(expr, (JBinary, PyBinary)) and expr.operator in _COMPARISONS
+
+
+def _is_invertible(comparison: JBinary) -> bool:
+    # `a < b < c` is one chained comparison whose last link is the outer node.
+    if _is_comparison(comparison.left) or _is_comparison(comparison.right):
+        return False
+    # Only numbers are totally ordered. A set orders by inclusion.
+    return comparison.operator in _EQUALITY or (
+        comparison.left.type in _NUMERIC and comparison.right.type in _NUMERIC
+    )
+
+
+def _is_read_as_truth_value(cursor: Cursor) -> bool:
+    node = cursor.value
+    parent = cursor.parent_tree_cursor()
+    while isinstance(parent.value, Parentheses):
+        node = parent.value
+        parent = parent.parent_tree_cursor()
+    value = parent.value
+    if isinstance(value, ControlParentheses):
+        return True
+    if isinstance(value, Unary):
+        return value.operator == Unary.Type.Not
+    if isinstance(value, Ternary):
+        return value.condition is node
+    if isinstance(value, Assert):
+        return value.condition is node
+    # `a or b` yields an operand, so its operands are truth values only if it is one.
+    if isinstance(value, JBinary) and value.operator in (JBinary.Type.And, JBinary.Type.Or):
+        return _is_read_as_truth_value(parent)
+    return False
+
 
 @categorize(_CodeQuality)
 class BooleanChecksNotInverted(Recipe):
@@ -71,7 +129,10 @@ class BooleanChecksNotInverted(Recipe):
         return (
             "Replace inverted boolean comparisons like `not (a == b)` with the "
             "equivalent direct operator (`a != b`), and remove double negations "
-            "like `not (not x)`."
+            "like `not (not x)`. An ordering such as `not (a < b)` is only "
+            "inverted where both operands' types resolve to numbers, a chained "
+            "comparison is left alone, and a double negation is only removed "
+            "where its value is read as a truth value, as in a condition."
         )
 
     @property
@@ -86,11 +147,11 @@ class BooleanChecksNotInverted(Recipe):
         class Visitor(PythonVisitor[ExecutionContext]):
             def visit_unary(
                 self, unary: Unary, p: ExecutionContext
-            ) -> Optional[Expression]:
-                unary = super().visit_unary(unary, p)
-
-                if not isinstance(unary, Unary):
-                    return unary
+            ) -> J:
+                visited = super().visit_unary(unary, p)
+                if not isinstance(visited, Unary):
+                    return visited
+                unary = visited
 
                 if unary.operator != Unary.Type.Not:
                     return unary
@@ -103,11 +164,15 @@ class BooleanChecksNotInverted(Recipe):
                     inner = inner.tree
 
                 # Double negation: not (not x) -> x
-                if isinstance(inner, Unary) and inner.operator == Unary.Type.Not:
+                if (
+                    isinstance(inner, Unary)
+                    and inner.operator == Unary.Type.Not
+                    and _is_read_as_truth_value(self.cursor)
+                ):
                     return inner.expression.replace(_prefix=unary.prefix)
 
                 # Inverted comparison: not (a == b) -> a != b
-                if isinstance(inner, JBinary):
+                if isinstance(inner, JBinary) and _is_invertible(inner):
                     inverse = _OPERATOR_INVERSE.get(inner.operator)
                     if inverse is not None:
                         return inner.padding.replace(

{openrewrite_migrate_python-0.15.1 → openrewrite_migrate_python-0.15.2}/src/openrewrite_code_quality_python/codequality/collapsible_if_statements.py

@@ -9,34 +9,33 @@ easier to follow.
 See: https://rules.sonarsource.com/python/RSPEC-S1066/
 """
 
-from typing import Any, List, Optional
+from typing import Any, List
 
 from rewrite import ExecutionContext, Recipe, TreeVisitor
 from rewrite.category import CategoryDescriptor
 from rewrite.decorators import categorize
 from rewrite.marketplace import Python
 from rewrite.markers import Markers
-from rewrite.python.tree import StatementExpression
+from rewrite.python.template.precedence import maybe_parenthesize
 from rewrite.python.visitor import PythonVisitor
-from rewrite.java.support_types import JLeftPadded, JRightPadded, Space
+from rewrite.java.support_types import Comment, JLeftPadded, JRightPadded, Space
 from rewrite.java.tree import (
-    Assignment,
     Binary as JBinary,
     Block,
     ControlParentheses,
-    Expression,
     If,
-    Lambda,
-    Parentheses,
-    Ternary,
+    J,
 )
 from rewrite.utils import random_id
 
 from openrewrite_code_quality_python.codequality._reindent import (
-    inherited_prefix,
     line_indent,
     reindent,
+    reindent_space,
 )
+from openrewrite_code_quality_python.codequality._trivia import concat, split_line
+
+_HOISTED_COMMENTS = "collapsible_if_statements.hoisted_comments"
 
 _CodeQuality = [
     *Python,
@@ -44,33 +43,12 @@ _CodeQuality = [
 ]
 
 
-def _binds_looser_than_and(expr: Expression) -> bool:
-    """Return True for the operand forms that ``and`` would capture.
-
-    Everything below ``and`` in Python's precedence table: ``or``, the
-    conditional expression, ``lambda``, ``:=`` (a ``J.Assignment`` here) and
-    ``yield`` (a ``Py.StatementExpression``).
-    """
-    if isinstance(expr, JBinary):
-        return expr.operator == JBinary.Type.Or
-    return isinstance(expr, (Ternary, Lambda, Assignment, StatementExpression))
-
-
-def _operand(expr: Expression, prefix: Space) -> Expression:
-    """Prepare *expr* as an operand of the merged ``and``, parenthesizing it
-    when its own operator would otherwise be captured."""
-    if _binds_looser_than_and(expr):
-        return Parentheses(
-            _id=random_id(),
-            _prefix=prefix,
-            _markers=Markers.EMPTY,
-            _tree=JRightPadded(
-                _element=expr.replace(_prefix=Space.EMPTY),
-                _after=Space.EMPTY,
-                _markers=Markers.EMPTY,
-            ),
-        )
-    return expr.replace(_prefix=prefix)
+def _with_comments_above(prefix: Space, comments: List[Comment]) -> Space:
+    """*prefix* with *comments* on their own lines just before the token it
+    leads into. Each comment's suffix must already end at that token's indent."""
+    if not comments:
+        return prefix
+    return Space(_comments=[*prefix.comments, *comments], _whitespace=prefix.whitespace)
 
 
 @categorize(_CodeQuality)
@@ -119,13 +97,20 @@ class CollapsibleIfStatements(Recipe):
 
     def editor(self) -> TreeVisitor[Any, ExecutionContext]:
         class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_else(self, else_: If.Else, p: ExecutionContext) -> J:
+                visited = super().visit_else(else_, p)
+                hoisted = self.cursor.get_message(_HOISTED_COMMENTS, [])
+                if not isinstance(visited, If.Else) or not hoisted:
+                    return visited
+                return visited.replace(_prefix=_with_comments_above(visited.prefix, hoisted))
+
             def visit_if(
                 self, if_: If, p: ExecutionContext
-            ) -> Optional[If]:
-                if_ = super().visit_if(if_, p)
-
-                if not isinstance(if_, If):
-                    return if_
+            ) -> J:
+                visited = super().visit_if(if_, p)
+                if not isinstance(visited, If):
+                    return visited
+                if_ = visited
 
                 # Outer if must have no else/elif
                 if if_.else_part is not None:
@@ -164,19 +149,50 @@ class CollapsibleIfStatements(Recipe):
                 ):
                     return if_
 
+                # An `elif` starts its line at the `elif` keyword, which the
+                # enclosing `Else` holds.
+                parent = self.cursor.parent_tree_cursor()
+                under_elif = isinstance(parent.value, If.Else)
+                outer_indent = line_indent(
+                    parent.value.prefix if isinstance(parent.value, If.Else) else if_.prefix
+                )
+                split = split_line(inner.prefix)
+                if (
+                    outer_indent is None
+                    or not header_indent.startswith(outer_indent)
+                    or split is None
+                ):
+                    return if_
+                # The outer header's trailing comment stays on the merged
+                # header. Comments on their own line before the inner `if`
+                # describe its condition, so they go above the merged header
+                # without the blank lines around them.
+                header_trailer, inner_leader = split
+                hoisted = reindent_space(
+                    Space(_comments=inner_leader.comments, _whitespace=""),
+                    header_indent,
+                    outer_indent,
+                ).comments
+
                 combined = JBinary(
                     _id=random_id(),
                     _prefix=if_.if_condition.tree.prefix,
                     _markers=Markers.EMPTY,
-                    _left=_operand(if_.if_condition.tree, Space.EMPTY),
+                    _left=if_.if_condition.tree.replace(_prefix=Space.EMPTY),
                     _operator=JLeftPadded(
                         _before=Space.SINGLE_SPACE,
                         _element=JBinary.Type.And,
                         _markers=Markers.EMPTY,
                     ),
-                    _right=_operand(inner.if_condition.tree, Space.SINGLE_SPACE),
+                    _right=reindent(inner.if_condition.tree, header_indent, outer_indent).replace(
+                        _prefix=Space.SINGLE_SPACE
+                    ),
                     _type=None,
                 )
+                combined = combined.replace(
+                    _left=maybe_parenthesize(combined, combined.left.id, combined.left),
+                    _right=maybe_parenthesize(combined, combined.right.id, combined.right),
+                )
 
                 new_condition = ControlParentheses(
                     _id=if_.if_condition.id,
@@ -193,18 +209,23 @@ class CollapsibleIfStatements(Recipe):
                 # level at a time, and each pass rebases the comments the
                 # previous one left at the level it dropped.
                 inner_body = reindent(inner_body, body_indent, header_indent)
-                first = inner_body._statements[0]
+                first = inner_body.padding.statements[0]
                 inner_body = inner_body.replace(
                     _statements=[
                         first.replace(
                             _element=first.element.replace(
-                                _prefix=inherited_prefix(inner.prefix, first.element.prefix)
+                                _prefix=concat(header_trailer, first.element.prefix)
                             )
                         ),
-                        *inner_body._statements[1:],
+                        *inner_body.padding.statements[1:],
                     ]
                 )
 
+                if under_elif:
+                    parent.put_message(_HOISTED_COMMENTS, hoisted)
+                else:
+                    if_ = if_.replace(_prefix=_with_comments_above(if_.prefix, hoisted))
+
                 return if_.replace(
                     _if_condition=new_condition,
                 ).padding.replace(