@openrewrite/rewrite 8.92.16 → 8.92.18

package/src/javascript/index.ts

@@ -29,14 +29,17 @@ export * from "./method-matcher";
 export * from "./format";
 export * from "./autodetect";
 export * from "./tree-debug";
+// The comparator visitors stay internal so what they compare is free to change.
+export {isEqual} from "./comparator";
+export * from "./type-report";
 export * from "./project-parser";
 
-export type {Scope} from "./scope";
+export type {Scope, Meaning, Reference} from "./scope";
 // `cursorOf` is deliberately absent: a visitor of one's own reaches `this.cursor` directly, and
 // the free functions that have no visitor to reach it through are already in this list.
 export {
-    scopeOf, namesDeclaredIn, namesDeclaredWithin, namesUsedIn, namesReferencedWithin, bindingNames, deconflict,
-    isValueReference, declarationsOf, compilationUnitOf, walk
+    scopeOf, namesDeclaredIn, namesDeclaredWithin, namesUsedIn, namesUsedWithin, namesReferencedWithin, bindingNames,
+    deconflict, isReference, isValueReference, isWrite, resolve, referencesOf, declarationsOf, compilationUnitOf, walk
 } from "./scope";
 export type {QuoteChar, AddImportOptions} from "./add-import";
 export {ImportStyle, moduleNameOf, AddImport} from "./add-import";

package/src/javascript/markers.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {Marker} from "../markers";
+import {Marker, MarkersKind} from "../markers";
 import {J} from "../java";
 import {JS} from "./tree";
 import {RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "../rpc";
@@ -24,10 +24,12 @@ import {
     StyleKind,
     TabsAndIndentsStyle,
     WrappingAndBracesStyle,
-    WrappingAndBracesStyleDetailKind
+    WrappingAndBracesStyleDetailKind,
+    prettierStyle
 } from "./style";
-import {Autodetect} from "./autodetect";
+import {Autodetect, autodetect} from "./autodetect";
 import {updateIfChanged} from "../util";
+import {NamedStyles, Style} from "../style";
 
 declare module "./tree" {
     namespace JS {
@@ -37,6 +39,7 @@ declare module "./tree" {
             readonly NonNullAssertion: "org.openrewrite.javascript.marker.NonNullAssertion";
             readonly DelegatedYield: "org.openrewrite.javascript.marker.DelegatedYield";
             readonly FunctionDeclaration: "org.openrewrite.javascript.marker.FunctionDeclaration";
+            readonly Computed: "org.openrewrite.javascript.marker.Computed";
         };
     }
 }
@@ -48,6 +51,7 @@ declare module "./tree" {
     Optional: "org.openrewrite.javascript.marker.Optional",
     NonNullAssertion: "org.openrewrite.javascript.marker.NonNullAssertion",
     FunctionDeclaration: "org.openrewrite.javascript.marker.FunctionDeclaration",
+    Computed: "org.openrewrite.javascript.marker.Computed",
 } as const;
 
 /**
@@ -80,6 +84,18 @@ export interface FunctionDeclaration extends Marker {
     readonly prefix: J.Space;
 }
 
+/**
+ * A name written in brackets where the model has room for an identifier only, as the
+ * member of `enum A { ['b'] }` is. The identifier holds the bracketed literal.
+ */
+export interface Computed extends Marker {
+    readonly kind: typeof JS.Markers.Computed;
+    /**
+     * The space before the closing bracket.
+     */
+    readonly suffix: J.Space;
+}
+
 /**
  * Registers an RPC codec for any marker that has a `prefix: J.Space` field.
  */
@@ -107,11 +123,26 @@ registerPrefixedMarkerCodec<Generator>(JS.Markers.Generator);
 registerPrefixedMarkerCodec<NonNullAssertion>(JS.Markers.NonNullAssertion);
 registerPrefixedMarkerCodec<FunctionDeclaration>(JS.Markers.FunctionDeclaration);
 
+RpcCodecs.registerCodec(JS.Markers.Computed, {
+    async rpcReceive(before: Computed, q: RpcReceiveQueue): Promise<Computed> {
+        return updateIfChanged(before, {
+            id: await q.receive(before.id),
+            suffix: await q.receive(before.suffix),
+        });
+    },
+
+    async rpcSend(after: Computed, q: RpcSendQueue): Promise<void> {
+        await q.getAndSend(after, a => a.id);
+        await q.getAndSend(after, a => a.suffix);
+    }
+});
+
 // Register codec for PrettierStyle (a NamedStyles that contains Prettier configuration)
 // Only serialize the variable fields; constant fields are defined in the interface
 RpcCodecs.registerCodec(StyleKind.PrettierStyle, {
     async rpcReceive(before: PrettierStyle, q: RpcReceiveQueue): Promise<PrettierStyle> {
-        return updateIfChanged(before, {
+        // the fields that never vary are not sent, so a marker first met here does not have them yet
+        return updateIfChanged(before.name ? before : {...prettierStyle(before.id, {}), ...before}, {
             id: await q.receive(before.id),
             config: await q.receive(before.config),
             prettierVersion: await q.receive(before.prettierVersion),
@@ -131,7 +162,7 @@ RpcCodecs.registerCodec(StyleKind.PrettierStyle, {
 // Only serialize the variable fields (id, styles); constant fields are defined in the interface
 RpcCodecs.registerCodec(StyleKind.Autodetect, {
     async rpcReceive(before: Autodetect, q: RpcReceiveQueue): Promise<Autodetect> {
-        return updateIfChanged(before, {
+        return updateIfChanged(before.name ? before : {...autodetect(before.id, []), ...before}, {
             id: await q.receive(before.id),
             styles: (await q.receiveList(before.styles))!,
         });
@@ -266,3 +297,44 @@ RpcCodecs.registerCodec(StyleKind.WrappingAndBracesStyle, {
         await q.getAndSend(after, a => a.keepWhenReformatting);
     }
 });
+
+const styleDetailKinds = new Set<string>([
+    ...Object.values(SpacesStyleDetailKind),
+    ...Object.values(WrappingAndBracesStyleDetailKind)
+]);
+
+function detailKind(styleKind: string, field: string): string | undefined {
+    const kind = `${styleKind}$${field.charAt(0).toUpperCase()}${field.slice(1)}`;
+    return styleDetailKinds.has(kind) ? kind : undefined;
+}
+
+function styleFromValue(value: any): Style {
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    const {"@c": kind, "@ref": _ref, ...fields} = value;
+    for (const [field, detail] of Object.entries(fields)) {
+        const kindOfDetail = detailKind(kind, field);
+        if (kindOfDetail && detail !== null && typeof detail === "object") {
+            fields[field] = {kind: kindOfDetail, ...detail};
+        }
+    }
+    return {kind, ...fields};
+}
+
+function styleToValue({kind, ...fields}: Style & Record<string, any>, ref: number): any {
+    for (const [field, detail] of Object.entries(fields)) {
+        if (detailKind(kind, field) && detail !== null && typeof detail === "object") {
+            const {kind: _kind, ...detailFields} = detail;
+            fields[field] = detailFields;
+        }
+    }
+    return {"@c": kind, "@ref": ref, ...fields};
+}
+
+// A plain NamedStyles has no codec on either side, so it travels in the shape Java's serializer gives it
+RpcCodecs.registerValueCodec(MarkersKind.NamedStyles, {
+    fromValue: (value: NamedStyles): NamedStyles => ({...value, styles: (value.styles ?? []).map(styleFromValue)}),
+    // Java's deserializer wants an object id on each style, and gives the first to the set itself
+    toValue: (after: NamedStyles) => ({...after, styles: after.styles.map((style, i) => styleToValue(style, i + 2))})
+});

package/src/javascript/method-matcher.ts

@@ -1,13 +1,20 @@
 import {Type} from "../java";
 import FullyQualified = Type.FullyQualified;
 
+/**
+ * Matches a method type against a `<declaring type> <name>(<args>)` pattern.
+ * `REWRITE_JAVASCRIPT_DUMP_TYPES=1` in a test run prints the pattern each call would match.
+ *
+ * With `matchOverrides`, the pattern's type may also be a supertype or interface of the declaring
+ * type, as in Java. A pattern naming a subtype of the declaring type never matches.
+ */
 export class MethodMatcher {
     private readonly packagePattern: string;
     private readonly typePattern: string;
     private readonly methodPattern: string;
     private readonly argumentPatterns: string[];
 
-    constructor(pattern: string) {
+    constructor(pattern: string, private readonly matchOverrides: boolean = false) {
         // Find the last space before the method spec (which contains parentheses)
         const firstParenIndex = pattern.indexOf('(');
         if (firstParenIndex === -1) {
@@ -31,7 +38,9 @@ export class MethodMatcher {
         } else {
             const lastDotIndex = typeSpec.lastIndexOf('.');
             if (lastDotIndex === -1) {
-                this.packagePattern = '*';
+                // As in Java, a type without a package matches only the type in no package, such as
+                // the global `Array` or the module `fs-extra`. `*.Array` matches any package.
+                this.packagePattern = '';
                 this.typePattern = typeSpec;
             } else {
                 // Check if we're splitting a *.. pattern incorrectly
@@ -71,23 +80,7 @@ export class MethodMatcher {
             return false;
         }
 
-        // Extract fully qualified name from declaringType
-        const fullyQualifiedName = FullyQualified.getFullyQualifiedName(method.declaringType);
-
-        // Split fully qualified name into package and type
-        const lastDotIndex = fullyQualifiedName.lastIndexOf('.');
-        const packageName = lastDotIndex === -1 ? '' : fullyQualifiedName.substring(0, lastDotIndex);
-        const typeName = lastDotIndex === -1 ? fullyQualifiedName : fullyQualifiedName.substring(lastDotIndex + 1);
-
-        // Match package
-        if (!this.matchesPackage(packageName)) {
-            return false;
-        }
-
-        // Match type (normalize primitives for matching)
-        const normalizedTypePattern = this.normalizePrimitiveType(this.typePattern);
-        const normalizedTypeName = this.normalizePrimitiveType(typeName);
-        if (!this.matchesPattern(normalizedTypePattern, normalizedTypeName)) {
+        if (!this.matchesTargetType(method.declaringType)) {
             return false;
         }
 
@@ -97,11 +90,30 @@ export class MethodMatcher {
         }
 
         // Match arguments - convert Type[] to string representations
-        const argStrings = method.parameterTypes.map(type => this.typeToString(type));
+        const argStrings = method.parameterTypes.map(type => MethodMatcher.typeName(type));
         return this.matchesArguments(argStrings);
     }
 
-    private typeToString(type: Type): string {
+    private matchesTargetType(type: Type | undefined): boolean {
+        const matches = (name: string) => this.matchesTypeName(name);
+        // A call on an untyped receiver declares on the unknown type, which a wildcard pattern
+        // matches by name. Java's matcher has no such case because Java calls are always typed.
+        return type?.kind === Type.Kind.Unknown
+            ? matches(FullyQualified.getFullyQualifiedName(type))
+            : Type.isOfTypeWithName(type, this.matchOverrides, matches);
+    }
+
+    private matchesTypeName(fullyQualifiedName: string): boolean {
+        const lastDotIndex = fullyQualifiedName.lastIndexOf('.');
+        const packageName = lastDotIndex === -1 ? '' : fullyQualifiedName.substring(0, lastDotIndex);
+        const typeName = lastDotIndex === -1 ? fullyQualifiedName : fullyQualifiedName.substring(lastDotIndex + 1);
+
+        return this.matchesPackage(packageName) &&
+            this.matchesPattern(this.normalizePrimitiveType(this.typePattern), this.normalizePrimitiveType(typeName));
+    }
+
+    /** The name an argument pattern compares against a parameter of this type. */
+    static typeName(type: Type): string {
         switch (type.kind) {
             case Type.Kind.Primitive:
                 return (type as Type.Primitive).keyword;
@@ -111,7 +123,7 @@ export class MethodMatcher {
                 return FullyQualified.getFullyQualifiedName((type as Type.Parameterized).type);
             case Type.Kind.Array:
                 const arrayType = type as Type.Array;
-                return this.typeToString(arrayType.elemType) + '[]';
+                return MethodMatcher.typeName(arrayType.elemType) + '[]';
             case Type.Kind.GenericTypeVariable:
                 return (type as Type.GenericTypeVariable).name;
             default:

package/src/javascript/node-resolution-result.ts

@@ -659,7 +659,7 @@ export function createNodeResolutionResultMarker(
         resolvedDependencies,
         packageManager,
         engines: normalizeEngines(packageJsonContent.engines),
-        npmrcConfigs,
+        npmrcConfigs: npmrcConfigs?.length ? npmrcConfigs : undefined,
     } as NodeResolutionResult;
 }
 
@@ -1022,7 +1022,8 @@ RpcCodecs.registerCodec(NodeResolutionResultKind, {
             resolvedDependencies: (await q.receiveList(before.resolvedDependencies)) || [],
             packageManager: await q.receive(before.packageManager),
             engines: await q.receive(before.engines),
-            npmrcConfigs: (await q.receiveList(before.npmrcConfigs)) || undefined,
+            // an empty list is how having none is sent
+            npmrcConfigs: await q.receiveList(before.npmrcConfigs).then(configs => configs?.length ? configs : undefined),
         });
     },
 

package/src/javascript/package-name.ts

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2026 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * The package a bare module specifier, or a path below `node_modules`, names. Attribution names a
+ * type declared in an installed package after it, so `@scope/pkg/sub` gives `@scope/pkg`.
+ */
+export function packageNameOf(specifier: string): string {
+    const segments = specifier.split('/');
+    return normalizePackageName(segments[0].startsWith('@') && segments.length > 1
+        ? `${segments[0]}/${segments[1]}`
+        : segments[0]);
+}
+
+/**
+ * The specifier consumers import a node_modules package under. A DefinitelyTyped package
+ * `@types/<pkg>` names `<pkg>`, and `@types/testing-library__react` names `@testing-library/react`.
+ * Types reached directly and through a declaration file's path then share one name.
+ */
+function normalizePackageName(packageName: string): string {
+    if (packageName.startsWith('@types/')) {
+        packageName = packageName.substring('@types/'.length);
+        // Decode __ encoding for scoped packages: testing-library__react -> @testing-library/react
+        if (packageName.includes('__')) {
+            const parts = packageName.split('__');
+            if (parts.length === 2) {
+                packageName = `@${parts[0]}/${parts[1]}`;
+            }
+        }
+    }
+    return packageName;
+}