@openrewrite/rewrite 8.79.4 → 8.79.6

package/src/java/rpc.ts

@@ -52,29 +52,34 @@ class TypeSender extends TypeVisitor<RpcSendQueue> {
 
     protected async visitAnnotation(annotation: Type.Annotation, q: RpcSendQueue): Promise<Type | undefined> {
         await q.getAndSend(annotation, a => asRef(a.type), t => this.visit(t, q));
-        // await q.getAndSendList(annotation, a => (a.values || []).map(v => asRef(v)), v => {
-        //     let value: any;
-        //     if (v.kind === Type.Kind.SingleElementValue) {
-        //         const single = v as Type.Annotation.SingleElementValue;
-        //         value = single.constantValue !== undefined ? single.constantValue : single.referenceValue;
-        //     } else {
-        //         const array = v as Type.Annotation.ArrayElementValue;
-        //         value = array.constantValues || array.referenceValues;
-        //     }
-        //     return `${Type.signature(v.element)}:${value == null ? "null" : value.toString()}`;
-        // }, async v => {
-        //     // Handle element values inline like the Java implementation
-        //     await q.getAndSend(v, e => asRef(e.element), elem => this.visit(elem, q));
-        //     if (v.kind === Type.Kind.SingleElementValue) {
-        //         const single = v as Type.Annotation.SingleElementValue;
-        //         await q.getAndSend(single, s => s.constantValue);
-        //         await q.getAndSend(single, s => asRef(s.referenceValue), ref => this.visit(ref, q));
-        //     } else if (v.kind === Type.Kind.ArrayElementValue) {
-        //         const array = v as Type.Annotation.ArrayElementValue;
-        //         await q.getAndSendList(array, a => a.constantValues || [], val => val == null ? "null" : val.toString());
-        //         await q.getAndSendList(array, a => (a.referenceValues || []).map(r => asRef(r)), t => Type.signature(t), r => this.visit(r, q));
-        //     }
-        // });
+        await q.getAndSendList(
+            annotation,
+            a => (a.values || []).map(v => asRef(v)),
+            v => Type.signature(v.element),
+            async v => {
+                await q.getAndSend(v, e => asRef(e.element), elem => this.visit(elem, q));
+                if (v.kind === Type.Kind.ArrayElementValue) {
+                    const array = v as Type.Annotation.ArrayElementValue;
+                    // constantValues are sent as raw JSON-native values; numeric subtypes
+                    // (int/long/float/double) and char/string distinctions are not preserved.
+                    await q.getAndSendList(
+                        array,
+                        a => a.constantValues,
+                        v => v == null ? "null" : v.toString(),
+                    );
+                    await q.getAndSendList(
+                        array,
+                        a => (a.referenceValues || []).map(r => asRef(r)),
+                        t => Type.signature(t),
+                        t => this.visit(t, q),
+                    );
+                } else {
+                    const single = v as Type.Annotation.SingleElementValue;
+                    await q.getAndSend(single, s => s.constantValue);
+                    await q.getAndSend(single, s => asRef(s.referenceValue), ref => this.visit(ref, q));
+                }
+            },
+        );
         return annotation;
     }
 
@@ -173,33 +178,29 @@ class TypeReceiver extends TypeVisitor<RpcReceiveQueue> {
 
     protected async visitAnnotation(annotation: Type.Annotation, q: RpcReceiveQueue): Promise<Type | undefined> {
         annotation.type = await q.receive(annotation.type, t => this.visit(t, q));
-        // annotation.values = await q.receiveList(annotation.values, async v => {
-        //     // Handle element values inline like the Java implementation
-        //     if (v.kind === Type.Kind.SingleElementValue) {
-        //         const single = v as Type.Annotation.SingleElementValue;
-        //         const element = await q.receive(single.element, elem => this.visit(elem, q));
-        //         const constantValue = await q.receive(single.constantValue);
-        //         const referenceValue = await q.receive(single.referenceValue, ref => this.visit(ref, q));
-        //         return {
-        //             kind: Type.Kind.SingleElementValue,
-        //             element,
-        //             constantValue,
-        //             referenceValue
-        //         } as Type.Annotation.SingleElementValue;
-        //     } else if (v.kind === Type.Kind.ArrayElementValue) {
-        //         const array = v as Type.Annotation.ArrayElementValue;
-        //         const element = await q.receive(array.element, elem => this.visit(elem, q));
-        //         const constantValues = await q.receiveList(array.constantValues);
-        //         const referenceValues = await q.receiveList(array.referenceValues, r => this.visit(r, q));
-        //         return {
-        //             kind: Type.Kind.ArrayElementValue,
-        //             element,
-        //             constantValues,
-        //             referenceValues
-        //         } as Type.Annotation.ArrayElementValue;
-        //     }
-        //     return v;
-        // }) || [];
+        annotation.values = (await q.receiveList(annotation.values, async v => {
+            const element = await q.receive((v as Type.Annotation.ElementValue).element, elem => this.visit(elem, q));
+            if (v.kind === Type.Kind.ArrayElementValue) {
+                const array = v as Type.Annotation.ArrayElementValue;
+                const constantValues = await q.receiveList(array.constantValues);
+                const referenceValues = await q.receiveList(array.referenceValues, r => this.visit(r, q));
+                return {
+                    kind: Type.Kind.ArrayElementValue,
+                    element,
+                    constantValues,
+                    referenceValues,
+                } as Type.Annotation.ArrayElementValue;
+            }
+            const single = v as Type.Annotation.SingleElementValue;
+            const constantValue = await q.receive(single.constantValue);
+            const referenceValue = await q.receive(single.referenceValue, ref => this.visit(ref, q));
+            return {
+                kind: Type.Kind.SingleElementValue,
+                element,
+                constantValue,
+                referenceValue,
+            } as Type.Annotation.SingleElementValue;
+        })) || [];
         return annotation;
     }
 

package/src/javascript/parser.ts

@@ -733,7 +733,7 @@ export class JavaScriptParserVisitor {
                 )),
                 end: this.prefix(node.getLastToken()!)
             },
-            type: this.mapType(node)
+            type: this.mapDeclarationType(node)
         };
     }
 
@@ -2723,7 +2723,7 @@ export class JavaScriptParserVisitor {
                     })),
                     end: this.prefix(node.getLastToken()!)
                 },
-                type: this.mapType(node)
+                type: this.mapDeclarationType(node)
             } satisfies J.ClassDeclaration as J.ClassDeclaration,
         }
     }
@@ -3414,7 +3414,7 @@ export class JavaScriptParserVisitor {
                 })),
                 end: this.prefix(node.getLastToken()!)
             },
-            type: this.mapType(node)
+            type: this.mapDeclarationType(node)
         };
     }
 
@@ -3475,7 +3475,7 @@ export class JavaScriptParserVisitor {
                     emptySpace)],
                 end: this.prefix(node.getLastToken()!)
             },
-            type: this.mapType(node) as Type.Class
+            type: this.mapDeclarationType(node) as Type.Class
         };
     }
 
@@ -4427,6 +4427,10 @@ export class JavaScriptParserVisitor {
         return this.typeMapping?.type(node);
     }
 
+    private mapDeclarationType(node: ts.ClassDeclaration | ts.ClassExpression | ts.InterfaceDeclaration | ts.EnumDeclaration): Type.FullyQualified | undefined {
+        return this.typeMapping?.declarationType(node);
+    }
+
     private mapPrimitiveType(node: ts.Node): Type.Primitive {
         return this.typeMapping?.primitiveType(node) ?? Type.Primitive.None;
     }

package/src/javascript/type-mapping.ts

@@ -83,6 +83,86 @@ export class JavaScriptTypeMapping {
         return type && this.getType(type);
     }
 
+    /**
+     * Resolve the declared type of a class / interface / enum / class-expression.
+     *
+     * Using {@code getTypeAtLocation} on these declaration nodes is unsafe: TypeScript returns
+     * the type of the declared *value*, not the type itself. For string or numeric enums that
+     * ends up being the union of enum literals, which on the JS side resolves to
+     * {@link Type.Primitive} (e.g. String for string enums). The Java-side RPC receiver then
+     * rejects it with "A class can only be type attributed with a fully qualified type name",
+     * because {@code J.ClassDeclaration.type} must be {@link Type.FullyQualified}.
+     *
+     * Instead, we resolve through the declaration's own symbol. For classes and interfaces we
+     * reuse the full type mapping pipeline (so members, methods, supertypes and type parameters
+     * are populated). For enums — which have no class-shaped representation in TypeScript — and
+     * any residual non-FQ result, we build a minimal class shell whose FQN and {@code classKind}
+     * are derived from the declaration itself.
+     */
+    declarationType(node: ts.ClassDeclaration | ts.ClassExpression | ts.InterfaceDeclaration | ts.EnumDeclaration): Type.FullyQualified | undefined {
+        const symbol = (node as { symbol?: ts.Symbol }).symbol
+            ?? (node.name ? this.checker.getSymbolAtLocation(node.name) : undefined);
+        if (!symbol) {
+            return undefined;
+        }
+
+        // For classes and interfaces `getDeclaredTypeOfSymbol` yields a class-shaped ts.Type whose
+        // symbol we can feed through the normal pipeline. For enums, however, TypeScript returns the
+        // union of enum literals — which on the JS side resolves to `Type.Primitive` (e.g. String for
+        // string enums) and therefore is NOT `FullyQualified`. The Java side then rejects it with
+        // "A class can only be type attributed with a fully qualified type name".
+        //
+        // Since JavaScript/TypeScript has no separate enum runtime representation, we build the
+        // class-shaped type directly from the declaration's own symbol. The `classKind` is derived
+        // from the declaration node kind, not the (lossy) resolved type.
+        let classKind: Type.Class.Kind;
+        if (ts.isEnumDeclaration(node)) {
+            classKind = Type.Class.Kind.Enum;
+        } else if (ts.isInterfaceDeclaration(node)) {
+            classKind = Type.Class.Kind.Interface;
+        } else {
+            classKind = Type.Class.Kind.Class;
+        }
+
+        const fullyQualifiedName = this.getFullyQualifiedNameFromSymbol(symbol);
+        const cacheKey = `decl:${classKind}:${fullyQualifiedName}`;
+        const cached = this.typeCache.get(cacheKey);
+        if (cached && Type.isFullyQualified(cached)) {
+            return cached as Type.FullyQualified;
+        }
+
+        // For classes and interfaces reuse the existing type-based path so that members, methods,
+        // supertypes and type parameters are populated. Enums (and any fallback that produced a
+        // non-FQ result) get a minimal class shell with the correct FQN + kind.
+        if (!ts.isEnumDeclaration(node)) {
+            const declaredType = this.checker.getDeclaredTypeOfSymbol(symbol);
+            if (declaredType) {
+                const mapped = this.getType(declaredType);
+                if (Type.isFullyQualified(mapped)) {
+                    this.typeCache.set(cacheKey, mapped);
+                    return mapped;
+                }
+            }
+        }
+
+        const classType: Type.Class = {
+            kind: Type.Kind.Class,
+            flags: 0,
+            classKind,
+            fullyQualifiedName,
+            typeParameters: [],
+            annotations: [],
+            interfaces: [],
+            members: [],
+            methods: [],
+            toJSON: function () {
+                return Type.signature(this);
+            }
+        } as Type.Class;
+        this.typeCache.set(cacheKey, classType);
+        return classType;
+    }
+
     private getType(type: ts.Type): Type {
         // Check for error types first - these indicate type-checking failures
         // and should not be processed further
@@ -990,7 +1070,10 @@ export class JavaScriptTypeMapping {
         if (!symbol) {
             return "unknown";
         }
+        return this.getFullyQualifiedNameFromSymbol(symbol);
+    }
 
+    private getFullyQualifiedNameFromSymbol(symbol: ts.Symbol): string {
         // First, check if this symbol is an import/alias
         // For imported types, we want to use the module specifier instead of the file path
         if (symbol.flags & ts.SymbolFlags.Alias) {

package/src/rpc/request/parse-project.ts

@@ -28,6 +28,12 @@ import {replaceMarkerByKind} from "../../markers";
 export interface ParseProjectResponseItem {
     id: UUID;
     sourceFileType: string;
+    /**
+     * Relative source path of the discovered file. Used by the Java side to report
+     * per-file failures (e.g., a failed `GetObject` deserialization) without aborting
+     * the rest of the stream. Optional for older callers.
+     */
+    sourcePath?: string;
 }
 
 /**
@@ -88,7 +94,7 @@ export class ParseProject {
                         });
                         const generator = parser.parse(...discovered.packageJsonFiles);
 
-                        for (const _ of discovered.packageJsonFiles) {
+                        for (const filePath of discovered.packageJsonFiles) {
                             const id = randomId();
                             localObjects.set(id, async (id: string) => {
                                 const sourceFile: SourceFile = (await generator.next()).value;
@@ -96,7 +102,8 @@ export class ParseProject {
                             });
                             resultItems.push({
                                 id,
-                                sourceFileType: "org.openrewrite.json.tree.Json$Document" // break cycle
+                                sourceFileType: "org.openrewrite.json.tree.Json$Document", // break cycle
+                                sourcePath: path.relative(relativeTo, filePath)
                             });
                         }
                     }
@@ -106,7 +113,7 @@ export class ParseProject {
                         const parser = Parsers.createParser("json", {ctx, relativeTo});
                         const generator = parser.parse(...discovered.lockFiles.json);
 
-                        for (const _ of discovered.lockFiles.json) {
+                        for (const filePath of discovered.lockFiles.json) {
                             const id = randomId();
                             localObjects.set(id, async (id: string) => {
                                 const sourceFile: SourceFile = (await generator.next()).value;
@@ -114,7 +121,8 @@ export class ParseProject {
                             });
                             resultItems.push({
                                 id,
-                                sourceFileType: "org.openrewrite.json.tree.Json$Document" // break cycle
+                                sourceFileType: "org.openrewrite.json.tree.Json$Document", // break cycle
+                                sourcePath: path.relative(relativeTo, filePath)
                             });
                         }
                     }
@@ -124,7 +132,7 @@ export class ParseProject {
                         const parser = Parsers.createParser("yaml", {ctx, relativeTo});
                         const generator = parser.parse(...discovered.lockFiles.yaml);
 
-                        for (const _ of discovered.lockFiles.yaml) {
+                        for (const filePath of discovered.lockFiles.yaml) {
                             const id = randomId();
                             localObjects.set(id, async (id: string) => {
                                 const sourceFile: SourceFile = (await generator.next()).value;
@@ -132,7 +140,8 @@ export class ParseProject {
                             });
                             resultItems.push({
                                 id,
-                                sourceFileType: "org.openrewrite.yaml.tree.Yaml$Documents" // break cycle
+                                sourceFileType: "org.openrewrite.yaml.tree.Yaml$Documents", // break cycle
+                                sourcePath: path.relative(relativeTo, filePath)
                             });
                         }
                     }
@@ -142,7 +151,7 @@ export class ParseProject {
                         const parser = Parsers.createParser("plainText", {ctx, relativeTo});
                         const generator = parser.parse(...discovered.lockFiles.text);
 
-                        for (const _ of discovered.lockFiles.text) {
+                        for (const filePath of discovered.lockFiles.text) {
                             const id = randomId();
                             localObjects.set(id, async (id: string) => {
                                 const sourceFile: SourceFile = (await generator.next()).value;
@@ -150,7 +159,8 @@ export class ParseProject {
                             });
                             resultItems.push({
                                 id,
-                                sourceFileType: "org.openrewrite.text.PlainText" // break cycle
+                                sourceFileType: "org.openrewrite.text.PlainText", // break cycle
+                                sourcePath: path.relative(relativeTo, filePath)
                             });
                         }
                     }
@@ -185,16 +195,18 @@ export class ParseProject {
                                 });
                                 resultItems.push({
                                     id,
-                                    sourceFileType: "org.openrewrite.javascript.tree.JS$CompilationUnit" // break cycle
+                                    sourceFileType: "org.openrewrite.javascript.tree.JS$CompilationUnit", // break cycle
+                                    sourcePath: path.relative(relativeTo, filePath)
                                 });
                             }
                         } else {
                             // Prettier is NOT available: auto-detect styles from parsed files
                             // Parse all files first to sample them
-                            const parsedFiles: {id: string, sourceFile: SourceFile}[] = [];
+                            const parsedFiles: {id: string, sourceFile: SourceFile, filePath: string}[] = [];
+                            let fileIndex = 0;
                             for await (const sourceFile of parser.parse(...discovered.jsFiles)) {
                                 const id = randomId();
-                                parsedFiles.push({id, sourceFile});
+                                parsedFiles.push({id, sourceFile, filePath: discovered.jsFiles[fileIndex++]});
                             }
 
                             // Sample all parsed files and build Autodetect marker using ProjectParser helper
@@ -203,7 +215,7 @@ export class ParseProject {
                             );
 
                             // Store thunks that add the Autodetect marker
-                            for (const {id, sourceFile} of parsedFiles) {
+                            for (const {id, sourceFile, filePath} of parsedFiles) {
                                 localObjects.set(id, async (newId: string) => {
                                     return {
                                         ...sourceFile,
@@ -213,7 +225,8 @@ export class ParseProject {
                                 });
                                 resultItems.push({
                                     id,
-                                    sourceFileType: "org.openrewrite.javascript.tree.JS$CompilationUnit" // break cycle
+                                    sourceFileType: "org.openrewrite.javascript.tree.JS$CompilationUnit", // break cycle
+                                    sourcePath: path.relative(relativeTo, filePath)
                                 });
                             }
                         }
@@ -224,7 +237,7 @@ export class ParseProject {
                         const parser = Parsers.createParser("yaml", {ctx, relativeTo});
                         const generator = parser.parse(...discovered.yamlFiles);
 
-                        for (const _ of discovered.yamlFiles) {
+                        for (const filePath of discovered.yamlFiles) {
                             const id = randomId();
                             localObjects.set(id, async (id: string) => {
                                 const sourceFile: SourceFile = (await generator.next()).value;
@@ -232,7 +245,8 @@ export class ParseProject {
                             });
                             resultItems.push({
                                 id,
-                                sourceFileType: "org.openrewrite.yaml.tree.Yaml$Documents" // break cycle
+                                sourceFileType: "org.openrewrite.yaml.tree.Yaml$Documents", // break cycle
+                                sourcePath: path.relative(relativeTo, filePath)
                             });
                         }
                     }
@@ -242,7 +256,7 @@ export class ParseProject {
                         const parser = Parsers.createParser("json", {ctx, relativeTo});
                         const generator = parser.parse(...discovered.jsonFiles);
 
-                        for (const _ of discovered.jsonFiles) {
+                        for (const filePath of discovered.jsonFiles) {
                             const id = randomId();
                             localObjects.set(id, async (id: string) => {
                                 const sourceFile: SourceFile = (await generator.next()).value;
@@ -250,7 +264,8 @@ export class ParseProject {
                             });
                             resultItems.push({
                                 id,
-                                sourceFileType: "org.openrewrite.json.tree.Json$Document" // break cycle
+                                sourceFileType: "org.openrewrite.json.tree.Json$Document", // break cycle
+                                sourcePath: path.relative(relativeTo, filePath)
                             });
                         }
                     }
@@ -260,7 +275,7 @@ export class ParseProject {
                         const parser = Parsers.createParser("plainText", {ctx, relativeTo});
                         const generator = parser.parse(...discovered.textFiles);
 
-                        for (const _ of discovered.textFiles) {
+                        for (const filePath of discovered.textFiles) {
                             const id = randomId();
                             localObjects.set(id, async (id: string) => {
                                 const sourceFile: SourceFile = (await generator.next()).value;
@@ -268,7 +283,8 @@ export class ParseProject {
                             });
                             resultItems.push({
                                 id,
-                                sourceFileType: "org.openrewrite.text.PlainText" // break cycle
+                                sourceFileType: "org.openrewrite.text.PlainText", // break cycle
+                                sourcePath: path.relative(relativeTo, filePath)
                             });
                         }
                     }