@openrewrite/rewrite 8.62.0 → 8.62.1

package/src/javascript/visitor.ts

@@ -18,7 +18,7 @@
 import {mapAsync} from "../util";
 import {SourceFile} from "../tree";
 import {ValidImmerRecipeReturnType} from "../visitor";
-import {Expression, J, JavaType, JavaVisitor, NameTree, Statement, TypedTree} from "../java";
+import {Expression, J, Type, JavaVisitor, NameTree, Statement, TypedTree} from "../java";
 import {createDraft, Draft, finishDraft} from "immer";
 import {isJavaScript, JS, JSX} from "./tree";
 import ComputedPropertyName = JS.ComputedPropertyName;
@@ -45,7 +45,7 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
     }
 
     // noinspection JSUnusedLocalSymbols
-    protected override async visitType(javaType: JavaType | undefined, p: P): Promise<JavaType | undefined> {
+    protected override async visitType(javaType: Type | undefined, p: P): Promise<Type | undefined> {
         return javaType;
     }
 
@@ -254,7 +254,7 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
             draft.function = await this.visitOptionalRightPadded(functionCall.function, p);
             draft.typeParameters = await this.visitOptionalContainer(functionCall.typeParameters, p);
             draft.arguments = await this.visitContainer(functionCall.arguments, p);
-            draft.functionType = await this.visitType(functionCall.functionType, p) as JavaType.Method | undefined;
+            draft.functionType = await this.visitType(functionCall.functionType, p) as Type.Method | undefined;
         });
     }
 
@@ -785,7 +785,7 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
             draft.name = await this.visitDefined<ComputedPropertyName>(computedPropMethod.name, p);
             draft.parameters = await this.visitContainer(computedPropMethod.parameters, p);
             draft.body = computedPropMethod.body && await this.visitDefined<J.Block>(computedPropMethod.body, p);
-            draft.methodType = computedPropMethod.methodType && (await this.visitType(computedPropMethod.methodType, p) as JavaType.Method);
+            draft.methodType = computedPropMethod.methodType && (await this.visitType(computedPropMethod.methodType, p) as Type.Method);
         });
     }
 
@@ -842,7 +842,7 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
             draft.propertyName = bindingElement.propertyName && await this.visitRightPadded(bindingElement.propertyName, p);
             draft.name = await this.visitDefined<TypedTree>(bindingElement.name, p);
             draft.initializer = bindingElement.initializer && await this.visitLeftPadded(bindingElement.initializer, p);
-            draft.variableType = bindingElement.variableType && (await this.visitType(bindingElement.variableType, p) as JavaType.Variable);
+            draft.variableType = bindingElement.variableType && (await this.visitType(bindingElement.variableType, p) as Type.Variable);
         });
     }
 

package/src/json/tree.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import {Markers} from "../markers";
-import {SourceFile, Tree, TreeKind} from "../tree";
+import {SourceFile, Tree} from "../tree";
 
 
 export interface Json extends Tree {
@@ -23,7 +23,6 @@ export interface Json extends Tree {
 
 export namespace Json {
     export const Kind = {
-        ...TreeKind,
         Array: "org.openrewrite.json.tree.Json$Array",
         Document: "org.openrewrite.json.tree.Json$Document",
         Empty: "org.openrewrite.json.tree.Json$Empty",

package/src/reference.ts

@@ -44,7 +44,7 @@ export function asRef<T extends {} | undefined>(obj: T): T extends undefined ? u
 }
 
 export function isRef(obj: any): obj is Reference {
-    return obj !== undefined && obj[REFERENCE_KEY] === true;
+    return obj !== undefined && obj !== null && obj[REFERENCE_KEY] === true;
 }
 
 export class ReferenceMap {

package/src/rpc/queue.ts

@@ -13,10 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {emptyMarkers, Marker, Markers, MarkersKind} from "../markers";
+import {emptyMarkers, Markers} from "../markers";
 import {saveTrace, trace} from "./trace";
 import {createDraft, finishDraft} from "immer";
-import {asRef, isRef, Reference, ReferenceMap} from "../reference";
+import {isRef, ReferenceMap} from "../reference";
 import {Writable} from "node:stream";
 
 /**
@@ -106,16 +106,6 @@ export class RpcSendQueue {
         this.q.push(d);
     }
 
-    sendMarkers<T extends { markers: Markers }>(parent: T, markersFn: (parent: T) => any): Promise<void> {
-        return this.getAndSend(parent, t2 => asRef(markersFn(t2)), async (markersRef: Markers & Reference) => {
-            await this.getAndSend(markersRef, m => m.id);
-            await this.getAndSendList(markersRef,
-                (m) => m.markers,
-                (marker: Marker) => marker.id
-            );
-        });
-    }
-
     getAndSend<T, U>(parent: T,
                      value: (parent: T) => U | undefined,
                      onChange?: (value: U) => Promise<any>): Promise<void> {
@@ -298,6 +288,12 @@ export class RpcReceiveQueue {
                         before = message.valueType === undefined ?
                             message.value :
                             this.newObj(message.valueType);
+                        if (ref !== undefined) {
+                            // For an object like JavaType that we will mutate in place rather than using
+                            // immutable updates because of its cyclic nature, the before instance will ultimately
+                            // be the same as the after instance below.
+                            this.refs.set(ref, before);
+                        }
                     }
                 // Intentional fall-through...
                 case RpcObjectState.CHANGE:

package/src/rpc/request/parse.ts

@@ -16,7 +16,7 @@
 import * as rpc from "vscode-jsonrpc/node";
 import {ExecutionContext} from "../../execution";
 import {UUID} from "node:crypto";
-import {ParserInput, Parsers} from "../../parser";
+import {Parser, ParserInput, Parsers} from "../../parser";
 import {randomId} from "../../uuid";
 import {produce} from "immer";
 import {SourceFile} from "../../tree";

package/src/rpc/rewrite-rpc.ts

@@ -115,7 +115,7 @@ export class RewriteRpc {
             );
         }, this.options.traceGetObjectInput);
 
-        const remoteObject = await q.receive<P>(this.localObjects.get(id));
+        const remoteObject = await q.receive<P>(localObject);
 
         const eof = (await q.take());
         if (eof.state !== RpcObjectState.END_OF_OBJECT) {
@@ -152,7 +152,8 @@ export class RewriteRpc {
     }
 
     async print(tree: SourceFile): Promise<string>;
-    async print<T extends Tree>(tree: T, cursor?: Cursor): Promise<string> {
+    async print(tree: Tree, cursor: Cursor): Promise<string>;
+    async print(tree: Tree, cursor?: Cursor): Promise<string> {
         if (!cursor && !isSourceFile(tree)) {
             throw new Error("Cursor is required for non-SourceFile trees");
         }

package/src/rpc/server.ts

@@ -28,7 +28,7 @@ import "../java";
 import "../javascript";
 
 // Not possible to set the stack size when executing from npx for security reasons
-require('v8').setFlagsFromString('--stack-size=4000');
+require('v8').setFlagsFromString('--stack-size=8000');
 
 interface ProgramOptions {
     logFile?: string;

package/src/test/rewrite-test.ts

@@ -61,8 +61,20 @@ export class RecipeSpec {
         this.dataTableAssertions[name] = allRows;
     }
 
-    async rewriteRun(...sourceSpecs: SourceSpec<any>[]): Promise<void> {
-        const specsByKind = sourceSpecs.reduce((groups, spec) => {
+    async rewriteRun(...sourceSpecs: (SourceSpec<any> | Generator<SourceSpec<any>, void, unknown>)[]): Promise<void> {
+        // Flatten generators into a list of sourceSpecs
+        const flattenedSpecs: SourceSpec<any>[] = [];
+        for (const specOrGenerator of sourceSpecs) {
+            if (specOrGenerator && typeof (specOrGenerator as any).next === 'function') {
+                for (const spec of specOrGenerator as Generator<SourceSpec<any>, void, unknown>) {
+                    flattenedSpecs.push(spec);
+                }
+            } else {
+                flattenedSpecs.push(specOrGenerator as SourceSpec<any>);
+            }
+        }
+
+        const specsByKind = flattenedSpecs.reduce((groups, spec) => {
             const kind = spec.kind;
             if (!groups[kind]) {
                 groups[kind] = [];
@@ -179,7 +191,11 @@ export class RecipeSpec {
             const b = spec.beforeRecipe ? spec.beforeRecipe(sourceFile) : sourceFile;
             if (b !== undefined) {
                 if (b instanceof Promise) {
-                    return [spec, await b];
+                    const mapped = await b;
+                    if (mapped === undefined) {
+                        throw new Error("Expected beforeRecipe to return a SourceFile, but got undefined. Did you forget a return statement?");
+                    }
+                    return [spec, mapped];
                 }
                 return [spec, b as SourceFile];
             }

package/src/text/tree.ts

@@ -23,7 +23,6 @@ export interface PlainText extends SourceFile {
 
 export namespace PlainText {
     export const Kind = {
-        ...TreeKind,
         PlainText: "org.openrewrite.text.PlainText",
         Snippet: "org.openrewrite.text.PlainText$Snippet"
     } as const

package/src/tree.ts

@@ -77,6 +77,21 @@ export class Cursor {
         return path;
     }
 
+    parentTree(level: number = 1): Cursor | undefined {
+        let c: Cursor | undefined = this.parent;
+        let treeCount = 0;
+        while (c) {
+            if (isTree(c.value)) {
+                treeCount++;
+                if (treeCount === level) {
+                    return c;
+                }
+            }
+            c = c.parent;
+        }
+        return undefined;
+    }
+
     firstEnclosing<T>(match: (value: any) => value is T): T | undefined {
         let c: Cursor | undefined = this;
         while (c) {