Merge branch 'main' into greg-antlr-trim-whitespace

Author: greg-at-moderne

rewrite-kotlin/src/main/java/org/openrewrite/kotlin/internal/KotlinPrinter.java

@@ -728,7 +728,7 @@ private J.ClassDeclaration visitClassDeclaration0(J.ClassDeclaration classDecl,
                 visitContainer("where", typeConstraints.getPadding().getConstraints(), JContainer.Location.TYPE_PARAMETERS, ",", "", p);
             }
 
-            if (!classDecl.getBody().getMarkers().findFirst(OmitBraces.class).isPresent()) {
+            if (classDecl.getBody() != null && !classDecl.getBody().getMarkers().findFirst(OmitBraces.class).isPresent()) {
                 visit(classDecl.getBody(), p);
             }
             afterSyntax(classDecl, p);

rewrite-kotlin/src/test/java/org/openrewrite/kotlin/KotlinTemplateTest.java

@@ -22,6 +22,10 @@
 import org.openrewrite.java.tree.J;
 import org.openrewrite.test.RewriteTest;
 
+import org.openrewrite.java.JavaTemplate;
+import org.openrewrite.java.tree.Statement;
+import org.openrewrite.test.TypeValidation;
+
 import java.net.URISyntaxException;
 import java.nio.file.Path;
 import java.util.List;
@@ -61,6 +65,45 @@ fun foo() {
           ));
     }
 
+    @Test
+    void addStatementToMethodInClass() {
+        rewriteRun(
+          spec -> spec.typeValidationOptions(TypeValidation.none())
+            .recipe(toRecipe(() -> new KotlinVisitor<>() {
+              @Override
+              public J visitMethodDeclaration(J.MethodDeclaration method, ExecutionContext ctx) {
+                  J.MethodDeclaration m = (J.MethodDeclaration) super.visitMethodDeclaration(method, ctx);
+                  if (m.getSimpleName().equals("configure")) {
+                      List<Statement> statements = m.getBody().getStatements();
+                      if (statements.stream().noneMatch(s -> s.toString().contains("println"))) {
+                          return JavaTemplate.builder("println(\"added\")")
+                            .contextSensitive()
+                            .build()
+                            .apply(getCursor(), statements.get(statements.size() - 1).getCoordinates().after());
+                      }
+                  }
+                  return m;
+              }
+          })),
+          kotlin(
+            """
+              class MyConfig {
+                  fun configure(value: Int) {
+                      val x = value + 1
+                  }
+              }
+              """,
+            """
+              class MyConfig {
+                  fun configure(value: Int) {
+                      val x = value + 1
+                      println("added")
+                  }
+              }
+              """
+          ));
+    }
+
     @Test
     void parserClasspath() {
         rewriteRun(

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

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

rewrite-python/rewrite/src/rewrite/java/extensions.py

@@ -17,7 +17,7 @@ def visit_container(v: 'JavaVisitor', container: Optional[JContainer[J2]], p: P)
     v.cursor = Cursor(v.cursor, container)
     before = v.visit_space(container.before, p)
     js = list_map(lambda el: v.visit_right_padded(el, p), container.padding.elements)
-    v.cursor = v.cursor.parent  # ty: ignore[invalid-assignment]  # cursor.parent is Optional[Cursor]; ty#1379
+    v.cursor = v.cursor.parent  # ty: ignore[invalid-assignment]  # cursor.parent is Optional[Cursor] (ty#628)
 
     return container if js is container.padding.elements and before is container.before else JContainer(before, js, container.markers)
 
@@ -30,7 +30,7 @@ def visit_right_padded(v: 'JavaVisitor', right: Optional[JRightPadded[T]], p: P)
     v.cursor = Cursor(v.cursor, right)
     if isinstance(t, Tree):
         t = v.visit_and_cast(t, T, p)
-    v.cursor = v.cursor.parent  # ty: ignore[invalid-assignment]  # cursor.parent is Optional[Cursor]; ty#1379
+    v.cursor = v.cursor.parent  # ty: ignore[invalid-assignment]  # cursor.parent is Optional[Cursor] (ty#628)
 
     if t is None:
         return None
@@ -50,7 +50,7 @@ def visit_left_padded(v: 'JavaVisitor', left: Optional[JLeftPadded[T]], p: P) ->
     t = left.element
     if isinstance(t, Tree):
         t = v.visit_and_cast(t, T, p)
-    v.cursor = v.cursor.parent  # ty: ignore[invalid-assignment]  # cursor.parent is Optional[Cursor]; ty#1379
+    v.cursor = v.cursor.parent  # ty: ignore[invalid-assignment]  # cursor.parent is Optional[Cursor] (ty#628)
 
     if left.element is t and before is left.before:
         return left

rewrite-python/rewrite/src/rewrite/java/support_types.py

@@ -589,5 +589,5 @@ def build_nullable(cls, before: Optional[JContainer[J2]], elements: Optional[Lis
     def empty(cls) -> JContainer[J2]:
         if cls._EMPTY is None:
             cls._EMPTY = JContainer(Space.EMPTY, [], Markers.EMPTY)
-        return cls._EMPTY  # type: ignore[return-value]  # _EMPTY is JContainer[J] but J2 is bound to J
+        return cls._EMPTY  # ty: ignore[invalid-return-type]  # _EMPTY is JContainer[J] but J2 is bound to J
 

rewrite-python/rewrite/src/rewrite/java/support_types.pyi

@@ -21,6 +21,7 @@ from rewrite.utils import replace_if_changed
 class J(Tree):
     @property
     def prefix(self) -> Space: ...
+    def replace(self, **kwargs: Any) -> Self: ...
     def is_acceptable(self, v: TreeVisitor[Any, P], p: P) -> bool: ...
     def accept(self, v: TreeVisitor[Any, P], p: P) -> Optional[Any]: ...
     def accept_java(self, v: 'JavaVisitor[P]', p: P) -> Optional['J']: ...
@@ -116,12 +117,14 @@ class JavaType(ABC):
         @property
         def bounds(self) -> List[JavaType]: ...
 
+    @dataclass
     class Union:
         _bounds: Optional[List[JavaType]]
 
         @property
         def bounds(self) -> List[JavaType]: ...
 
+    @dataclass
     class Intersection:
         _bounds: Optional[List[JavaType]]
 

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[unresolved-attribute]  # PrinterFactory.current() is always set
+        return PrinterFactory.current().create_printer(cursor)  # ty: ignore[unresolved-attribute]  # guarded: PrinterFactory.current() always set here
 
     def is_acceptable(self, v: TreeVisitor[Any, P], p: P) -> bool:
         return v.is_adaptable_to(ParseErrorVisitor)

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

@@ -774,7 +774,7 @@ def visit_Import(self, node):
             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))
+            return imp.replace(prefix=prefix, qualid=imp.qualid.replace(prefix=imp.prefix))  # ty: ignore[unresolved-attribute]  # imp is Import at runtime
 
         prefix = self.__source_before('import')
         names_prefix = self.__whitespace()
@@ -1197,7 +1197,7 @@ def __convert_match_pattern(self, node):
                             py.MatchCase.Pattern.Kind.GROUP,
                             JContainer(
                                 prefix,
-                                [JRightPadded(inner.replace(prefix=inner_prefix) if hasattr(inner, 'replace') else inner, Space.EMPTY, Markers.EMPTY)],  # ty: ignore[call-non-callable]
+                                [JRightPadded(inner.replace(prefix=inner_prefix) if hasattr(inner, 'replace') else inner, Space.EMPTY, Markers.EMPTY)],
                                 Markers.EMPTY
                             ),
                             None
@@ -2243,7 +2243,7 @@ def __map_decorator(self, decorator) -> j.Annotation:
             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
+            wrapped: Expression = name  # ty: ignore[invalid-assignment]
             for i in range(len(extra_parens) - 1, -1, -1):
                 paren_prefix, _ = extra_parens[i]
                 suffix = self.__whitespace()
@@ -2769,7 +2769,7 @@ def __convert_type(self, node) -> Optional[TypeTree]:
         prefix = self.__whitespace()
         converted_type = self.__convert_internal(node, self.__convert_type, self.__convert_type_mapper)
         if isinstance(converted_type, TypeTree):
-            return converted_type.replace(prefix=prefix)  # ty: ignore[unresolved-attribute]  # TypeTree base class doesn't have replace
+            return converted_type.replace(prefix=prefix)  # TypeTree base class doesn't have replace
         else:
             return py.ExpressionTypeTree(
                 random_id(),
@@ -3065,14 +3065,14 @@ def ident_or_field(parts: List[str]) -> NameTree:
         return ident_or_field(name.split('.'))
 
     def __convert_all(self, trees: Sequence) -> List[J2]:
-        return [c for tree in trees if (c := self.__convert(tree)) is not None]  # ty: ignore[invalid-return-type]
+        return [c for tree in trees if (c := self.__convert(tree)) is not None]  # ty: ignore[invalid-return-type]  # J list, J2 is bound to J
 
     def __convert_block(self, statements: Sequence[Statement], delim: str = ':') -> j.Block:
         prefix = self.__source_before(delim)
         if statements:
-            statements = [self.__pad_statement(cast(ast.stmt, s)) for s in statements]  # ty: ignore[invalid-assignment]
+            statements = [self.__pad_statement(cast(ast.stmt, s)) for s in statements]  # ty: ignore[invalid-assignment]  # padded statement list type
         else:
-            statements = [self.__pad_right(j.Empty(random_id(), Space.EMPTY, Markers.EMPTY), Space.EMPTY)]  # ty: ignore[invalid-assignment]
+            statements = [self.__pad_right(j.Empty(random_id(), Space.EMPTY, Markers.EMPTY), Space.EMPTY)]  # ty: ignore[invalid-assignment]  # padded statement list type
         return j.Block(
             random_id(),
             prefix,
@@ -3095,7 +3095,7 @@ def __pad_statement(self, stmt: ast.stmt) -> JRightPadded[Statement]:
             self._token_idx = save_idx
             padding = Space.EMPTY
             markers = Markers.EMPTY
-        return JRightPadded(statement, padding, markers)  # ty: ignore[invalid-return-type]  # statement is J|None from __convert_statement
+        return JRightPadded(statement, padding, markers)  # ty: ignore[invalid-return-type]  # statement is J from __convert_statement
 
     def __pad_list_element(self, element: J2, last: bool = False, pad_last: bool = True, delim: str = ',',
                            end_delim: Optional[str] = None) -> JRightPadded[J2]:

rewrite-python/rewrite/src/rewrite/python/_py2_parser_visitor.py

@@ -172,7 +172,7 @@ def _convert_leaf(self, leaf: parso_tree.PythonLeaf) -> Optional[j.J]:
         prefix = self._parse_space(leaf.prefix)
 
         # parso 0.7.x uses lowercase type names (e.g. 'name', 'number')
-        leaf_type = leaf.type.upper()
+        leaf_type = leaf.type.upper()  # ty: ignore[unresolved-attribute]  # parso leaf.type is always str
 
         if leaf_type == 'NAME' or leaf_type == 'KEYWORD':
             return j.Identifier(

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

@@ -22,7 +22,7 @@ def visit_compilation_unit(self, cu: CompilationUnit, p: P) -> J:
         return super().visit_compilation_unit(cu, p)
 
     def visit_statement(self, stmt: Statement, p: P) -> J:
-        stmt = super().visit_statement(stmt, p)
+        stmt = super().visit_statement(stmt, p)  # ty: ignore[invalid-assignment]  # visitor covariance
 
         parent_cursor = self.cursor.parent_tree_cursor()
         top_level = isinstance(parent_cursor.value, CompilationUnit)
@@ -41,7 +41,7 @@ def visit_statement(self, stmt: Statement, p: P) -> J:
             else:
                 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)
-                stmt = _adjusted_lines_for_tree(stmt, min_lines, self._style.keep_maximum.in_declarations)
+                stmt = _adjusted_lines_for_tree(stmt, min_lines, self._style.keep_maximum.in_declarations)  # ty: ignore[invalid-assignment]  # visitor covariance
         else:
             in_block = isinstance(parent_cursor.value, Block)
             in_class = in_block and isinstance(parent_cursor.parent_tree_cursor().value, ClassDeclaration)
@@ -63,7 +63,7 @@ def visit_statement(self, stmt: Statement, p: P) -> J:
             if prev_import:
                 min_lines = max(min_lines, self._style.minimum.after_local_imports)
 
-            stmt = _adjusted_lines_for_tree(stmt, min_lines, max_lines)
+            stmt = _adjusted_lines_for_tree(stmt, min_lines, max_lines)  # ty: ignore[invalid-assignment]  # visitor covariance
         return stmt
 
     def post_visit(self, tree: T, p: P) -> Optional[T]: