@openrewrite/rewrite 8.81.9 → 8.81.11

package/src/preconditions.ts

@@ -18,8 +18,66 @@ import {Cursor, isSourceFile, SourceFile, Tree} from './tree';
 import {Recipe} from "./recipe";
 import {ExecutionContext} from "./execution";
 
+/**
+ * Recipe-identity placeholder for use as a precondition.
+ *
+ * Captures a Java recipe class name + options without instantiating the
+ * recipe or firing an RPC. The framework introspects a
+ * ``check(RecipeRef, editor)`` wrapper at PrepareRecipe time and emits
+ * the recipe identity directly in
+ * ``PrepareRecipeResponse.editPreconditions``. The Java host's
+ * ``PreparedRecipeCache.instantiateVisitor`` constructs the recipe via
+ * Jackson and uses its visitor.
+ *
+ * This avoids requiring the recipe author to do an RPC at ``editor()``
+ * construction time, which would otherwise block in-process unit tests
+ * that don't have an active RPC connection.
+ *
+ * If ``localVisitor`` is provided, in-process callers (without an active
+ * RPC connection) evaluate the gate against that visitor instead of
+ * short-circuiting to "always matches". This preserves real filtering
+ * behavior in unit tests while still letting the host evaluate the gate
+ * over the wire when an RPC connection is present.
+ *
+ * Helpers in ``@openrewrite/rewrite/javascript/preconditions``
+ * (``usesMethod``, ``usesType``, ``hasSourcePath``, ``findMethods``,
+ * ``findTypes``) return ``RecipeRef`` instances populated with the
+ * matching native TS visitor where one exists.
+ */
+export class RecipeRef {
+    constructor(
+        readonly recipeName: string,
+        readonly options: Readonly<Record<string, any>> = {},
+        readonly localVisitor?: TreeVisitor<any, ExecutionContext>
+    ) {
+    }
+}
+
+/**
+ * Composite of nested precondition operands joined by an operator.
+ *
+ * Mirrors Java's ``Preconditions.or``/``and``/``not``: a gate that
+ * short-circuits over its operands. ``op`` is one of ``"or"`` / ``"and"`` /
+ * ``"not"``. Operands may be ``TreeVisitor``, ``Recipe``, ``RecipeRef``,
+ * or another ``CompositePrecondition``.
+ *
+ * The framework promotes the composite to a structured wire entry at
+ * PrepareRecipe time; the Java host's ``RewriteRpc.matchAll`` rebuilds
+ * the visitor via the matching ``Preconditions`` factory so the gate runs
+ * locally and the visit RPC is skipped for files the gate rejects.
+ */
+export class CompositePrecondition {
+    constructor(
+        readonly op: "or" | "and" | "not",
+        readonly operands: ReadonlyArray<CheckArg>
+    ) {
+    }
+}
+
+export type CheckArg = Recipe | TreeVisitor<any, ExecutionContext> | RecipeRef | CompositePrecondition;
+
 export async function check<T extends Tree>(
-    checkCondition: Recipe | Promise<Recipe> | TreeVisitor<T, ExecutionContext> | Promise<TreeVisitor<T, ExecutionContext>> | boolean,
+    checkCondition: CheckArg | Promise<CheckArg> | boolean,
     v: TreeVisitor<T, ExecutionContext> | Promise<TreeVisitor<T, ExecutionContext>>
 ): Promise<TreeVisitor<T, ExecutionContext>> {
     const resolvedCheck = await checkCondition;
@@ -31,15 +89,52 @@ export async function check<T extends Tree>(
     return new Check(resolvedCheck, resolvedV);
 }
 
+/**
+ * OR-compose precondition checks. Mirrors Java's
+ * ``Preconditions.or(visitor...)``: the gate matches if any operand
+ * matches. Requires at least two operands; a single-operand OR has no
+ * value over a bare ``check``.
+ */
+export function or(...operands: CheckArg[]): CompositePrecondition {
+    if (operands.length < 2) {
+        throw new Error("Preconditions.or requires at least two operands");
+    }
+    return new CompositePrecondition("or", operands);
+}
+
+/**
+ * AND-compose precondition checks. The outer ``editPreconditions`` list
+ * is already AND-composed by the host, so this is mainly useful as an
+ * operand of ``or``/``not``.
+ */
+export function and(...operands: CheckArg[]): CompositePrecondition {
+    if (operands.length < 2) {
+        throw new Error("Preconditions.and requires at least two operands");
+    }
+    return new CompositePrecondition("and", operands);
+}
+
+/**
+ * Negate a precondition check. Mirrors Java's ``Preconditions.not(visitor)``:
+ * the gate matches iff the operand does not.
+ */
+export function not(operand: CheckArg): CompositePrecondition {
+    return new CompositePrecondition("not", [operand]);
+}
+
 export class Check<T extends Tree> extends TreeVisitor<T, ExecutionContext> {
     constructor(
-        readonly check: TreeVisitor<T, ExecutionContext> | Recipe,
+        readonly check: CheckArg,
         readonly v: TreeVisitor<T, ExecutionContext>
     ) {
         super();
     }
 
     async isAcceptable(sourceFile: SourceFile, ctx: ExecutionContext): Promise<boolean> {
+        if (this.check instanceof RecipeRef || this.check instanceof CompositePrecondition) {
+            // RecipeRef / Composite have no in-process is_acceptable — defer to the wrapped editor.
+            return this.v.isAcceptable(sourceFile, ctx);
+        }
         return await (await this.checkVisitor()).isAcceptable(sourceFile, ctx) &&
             await this.v.isAcceptable(sourceFile, ctx);
     }
@@ -53,12 +148,31 @@ export class Check<T extends Tree> extends TreeVisitor<T, ExecutionContext> {
                 : this.v.visit<R>(tree, ctx);
         }
 
-        const checkResult = parent !== undefined
-            ? await (await this.checkVisitor()).visit(tree, ctx, parent)
-            : await (await this.checkVisitor()).visit(tree, ctx);
+        // In-process fallback for a RecipeRef: if a localVisitor was
+        // provided, evaluate the gate against it (preserves real filtering
+        // for unit tests); otherwise treat as "always matches" so the
+        // wrapped editor still runs. Wire-side optimization (skip the
+        // visit RPC when the precondition rejects the file) lives in
+        // optimizePreconditions and is independent of localVisitor.
+        if (this.check instanceof RecipeRef) {
+            if (this.check.localVisitor !== undefined) {
+                const localResult = parent !== undefined
+                    ? await this.check.localVisitor.visit(tree, ctx, parent)
+                    : await this.check.localVisitor.visit(tree, ctx);
+                if (localResult === (tree as unknown as T)) {
+                    return tree as unknown as R;
+                }
+            }
+            return parent !== undefined
+                ? this.v.visit<R>(tree, ctx, parent)
+                : this.v.visit<R>(tree, ctx);
+        }
+
+        const matched = this.check instanceof CompositePrecondition
+            ? await evaluateComposite(this.check, tree, ctx, parent)
+            : await this.runLeafCheck(tree, ctx, parent);
 
-        // If check visitor modified the tree (returned something different), run the main visitor
-        if (checkResult !== (tree as unknown as T)) {
+        if (matched) {
             return parent !== undefined
                 ? this.v.visit<R>(tree, ctx, parent)
                 : this.v.visit<R>(tree, ctx);
@@ -67,7 +181,75 @@ export class Check<T extends Tree> extends TreeVisitor<T, ExecutionContext> {
         return tree as unknown as R;
     }
 
+    private async runLeafCheck(tree: Tree, ctx: ExecutionContext, parent?: Cursor): Promise<boolean> {
+        const checkResult = parent !== undefined
+            ? await (await this.checkVisitor()).visit(tree, ctx, parent)
+            : await (await this.checkVisitor()).visit(tree, ctx);
+        return checkResult !== (tree as unknown as T);
+    }
+
     private async checkVisitor(): Promise<TreeVisitor<any, ExecutionContext>> {
-        return this.check instanceof Recipe ? this.check.editor() : this.check;
+        return this.check instanceof Recipe ? this.check.editor() : (this.check as TreeVisitor<any, ExecutionContext>);
+    }
+}
+
+/**
+ * Evaluate a {@link CompositePrecondition} in-process for unit tests and
+ * direct callers that don't have a live RPC. Mirrors Java's
+ * ``Preconditions.or``/``and``/``not`` semantics. Returns ``true`` iff the
+ * gate would let the wrapped visitor run.
+ */
+async function evaluateComposite(
+    composite: CompositePrecondition,
+    tree: Tree,
+    ctx: ExecutionContext,
+    parent?: Cursor
+): Promise<boolean> {
+    const operands = composite.operands;
+    switch (composite.op) {
+        case "or":
+            for (const operand of operands) {
+                if (await operandMatches(operand, tree, ctx, parent)) return true;
+            }
+            return false;
+        case "and":
+            for (const operand of operands) {
+                if (!(await operandMatches(operand, tree, ctx, parent))) return false;
+            }
+            return true;
+        case "not":
+            if (operands.length !== 1) {
+                throw new Error("CompositePrecondition op=not requires exactly one operand");
+            }
+            return !(await operandMatches(operands[0], tree, ctx, parent));
+    }
+}
+
+async function operandMatches(
+    operand: CheckArg,
+    tree: Tree,
+    ctx: ExecutionContext,
+    parent?: Cursor
+): Promise<boolean> {
+    if (operand instanceof RecipeRef) {
+        // If a localVisitor was provided, evaluate against it for real;
+        // otherwise short-circuit to "always matches" so the wrapped
+        // editor still runs in unit tests. The host evaluates the gate
+        // for real once the response goes over the wire.
+        if (operand.localVisitor === undefined) {
+            return true;
+        }
+        const result = parent !== undefined
+            ? await operand.localVisitor.visit(tree, ctx, parent)
+            : await operand.localVisitor.visit(tree, ctx);
+        return result !== tree;
+    }
+    if (operand instanceof CompositePrecondition) {
+        return evaluateComposite(operand, tree, ctx, parent);
     }
+    const visitor = operand instanceof Recipe ? await operand.editor() : operand;
+    const result = parent !== undefined
+        ? await visitor.visit(tree, ctx, parent)
+        : await visitor.visit(tree, ctx);
+    return result !== tree;
 }

package/src/rpc/request/prepare-recipe.ts

@@ -17,7 +17,7 @@ import * as rpc from "vscode-jsonrpc/node";
 import {MessageConnection} from "vscode-jsonrpc/node";
 import {Recipe, RecipeDescriptor, ScanningRecipe} from "../../recipe";
 import {SnowflakeId} from "@akashrajpurohit/snowflake-id";
-import {Check} from "../../preconditions";
+import {Check, CheckArg, CompositePrecondition, RecipeRef} from "../../preconditions";
 import {RpcRecipe} from "../recipe";
 import {TreeVisitor} from "../../visitor";
 import {ExecutionContext} from "../../execution";
@@ -109,8 +109,9 @@ export class PrepareRecipe {
         }
 
         if (visitor! instanceof Check) {
-            if (visitor.check instanceof RpcRecipe) {
-                preconditions.push({visitorName: phase === "edit" ? visitor.check.editVisitor : visitor.check.scanVisitor!});
+            const wireEntry = this.conditionWireEntry(visitor.check, phase);
+            if (wireEntry) {
+                preconditions.push(wireEntry);
                 recipe = Object.assign(
                     Object.create(Object.getPrototypeOf(recipe)),
                     recipe,
@@ -135,6 +136,42 @@ export class PrepareRecipe {
         return recipe;
     }
 
+    /**
+     * Translate a precondition condition (operand) to a wire entry.
+     *
+     * Mirrors the Java {@code PrepareRecipeResponse.Precondition} schema:
+     * leaves carry {@code visitorName} (+ optional options); composites
+     * carry {@code op} ({@code "or"}/{@code "and"}/{@code "not"}) and a
+     * nested {@code operands} list. Returns {@code undefined} when the
+     * condition can't be serialized — the caller leaves the wrapper
+     * intact so the gate runs in-process as a fallback.
+     */
+    private static conditionWireEntry(condition: CheckArg, phase: "edit" | "scan"): Precondition | undefined {
+        if (condition instanceof CompositePrecondition) {
+            const operands: Precondition[] = [];
+            for (const operand of condition.operands) {
+                const entry = this.conditionWireEntry(operand, phase);
+                if (entry === undefined) {
+                    return undefined;
+                }
+                operands.push(entry);
+            }
+            return {op: condition.op, operands};
+        }
+        // Common case: helpers like usesMethod / usesType return a lightweight
+        // RecipeRef so the recipe author can declare a precondition without
+        // firing an RPC at editor() time. The Java host's
+        // PreparedRecipeCache.instantiateVisitor constructs the named recipe
+        // via Jackson and uses its visitor.
+        if (condition instanceof RecipeRef) {
+            return {visitorName: condition.recipeName, visitorOptions: {...condition.options}};
+        }
+        if (condition instanceof RpcRecipe) {
+            return {visitorName: phase === "edit" ? condition.editVisitor : condition.scanVisitor!};
+        }
+        return undefined;
+    }
+
     private static async visitorTypePrecondition(preconditions: Precondition[], v: TreeVisitor<any, ExecutionContext>): Promise<Precondition[]> {
         let treeType: string | undefined;
 
@@ -183,7 +220,20 @@ export interface PrepareRecipeResponse {
     delegatesTo?: DelegatesTo
 }
 
+/**
+ * Either a leaf (a single visitor identified by {@code visitorName} +
+ * optional {@code visitorOptions}) or a composite of nested preconditions
+ * joined by {@code op} ({@code "or"} / {@code "and"} / {@code "not"}).
+ *
+ * When {@code op} is undefined the entry is a leaf and {@code visitorName}
+ * is required; when {@code op} is set, {@code operands} carries the
+ * children and the visitor fields are ignored. The composite form mirrors
+ * Java's {@code Preconditions.or}/{@code and}/{@code not} so remote
+ * languages can express the same gate shapes the Java side does.
+ */
 export interface Precondition {
-    visitorName: string
+    visitorName?: string
     visitorOptions?: {}
+    op?: "or" | "and" | "not"
+    operands?: Precondition[]
 }