JavaScript: Allow incomplete \x hex escape sequences (#6174)

Legacy JS source files can contain incomplete `\x` hex code escape sequences, as in this regex example: `/\x-(.*)/`. The parser should not fail when parsing JS source files like this.

Additionally, the parser will now allow object literals with multiple properties of the same name. There is a corresponding `org.openrewrite.javascript.migrate.es6.remove-duplicate-object-keys` ES6 upgrade recipe to deduplicate these, as ES6 does not allow this anymore.

Author: knutwannheden

rewrite-java/src/main/java/org/openrewrite/java/RemoveImport.java

@@ -112,10 +112,10 @@ public RemoveImport(String type, boolean force) {
             JavaSourceFile c = cu;
 
             boolean keepImport = !force && (typeUsed || !otherTypesInPackageUsed.isEmpty() && type.endsWith(".*"));
-            AtomicReference<Space> spaceForNextImport = new AtomicReference<>();
+            AtomicReference<@Nullable Space> spaceForNextImport = new AtomicReference<>();
             c = c.withImports(ListUtils.flatMap(c.getImports(), import_ -> {
-                if (spaceForNextImport.get() != null) {
-                    Space removedPrefix = spaceForNextImport.get();
+                Space removedPrefix = spaceForNextImport.get();
+                if (removedPrefix != null) {
                     Space currentPrefix = import_.getPrefix();
                     if (removedPrefix.getLastWhitespace().isEmpty() ||
                         (countTrailingLinebreaks(removedPrefix) > countTrailingLinebreaks(currentPrefix))) {

rewrite-javascript/rewrite/src/index.ts

@@ -36,9 +36,10 @@ export * from "./run";
 // register all recipes in this package
 export async function activate(registry: RecipeRegistry): Promise<void> {
     const {OrderImports} = await import("./recipe/index.js");
-    const {ModernizeOctalLiterals} = await import("./javascript/migrate/es6/index.js");
+    const {ModernizeOctalLiterals, RemoveDuplicateObjectKeys} = await import("./javascript/migrate/es6/index.js");
     registry.register(OrderImports);
     registry.register(ModernizeOctalLiterals);
+    registry.register(RemoveDuplicateObjectKeys);
 }
 
 RpcCodecs.registerCodec(MarkersKind.ParseExceptionResult, {

rewrite-javascript/rewrite/src/java/formatting-utils.ts

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2025 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.
+ */
+
+import {J} from "../java";
+import {produce} from "immer";
+
+/**
+ * Applies the prefix from a removed element to the next element.
+ *
+ * This is used when removing elements from a list to preserve formatting:
+ * - If the next element has no comments (or only an inline trailing comment to remove),
+ *   uses the removed element's prefix whitespace
+ * - If the next element has comments to preserve, keeps the next element's whitespace
+ *   to maintain proper spacing (e.g., blank lines before comments)
+ * - Removes inline line comments (//...) that were on the removed element's line
+ *
+ * @param removedElement The element that was removed
+ * @param nextElement The element that follows the removed one
+ * @returns The next element with adjusted prefix, or the original if no changes needed
+ */
+export function applyRemovedElementPrefix<T extends J>(removedElement: J, nextElement: T): T {
+    if (!removedElement.prefix || !nextElement.prefix) {
+        return nextElement;
+    }
+
+    const removedPrefix = removedElement.prefix;
+    const currentPrefix = nextElement.prefix;
+    const currentComments = currentPrefix.comments || [];
+
+    // If the next element has no comments, just use the removed element's prefix entirely
+    if (currentComments.length === 0) {
+        if (currentPrefix === removedPrefix) {
+            return nextElement;
+        }
+        return produce(nextElement, draft => {
+            draft.prefix = removedPrefix;
+        });
+    }
+
+    // The next element has comments - check if we need to remove inline line comments
+    const currentWhitespace = currentPrefix.whitespace || '';
+    const hasLeadingNewline = /[\r\n]/.test(currentWhitespace);
+
+    let commentsToKeep = currentComments;
+    if (!hasLeadingNewline && currentComments.length > 0) {
+        // First comment has no leading newline - check if it's an inline line comment
+        const firstComment: any = currentComments[0];
+        const commentText = firstComment.text || firstComment.message || '';
+        const isLineComment = commentText.includes('//') || firstComment.multiline === false;
+
+        if (isLineComment) {
+            // Remove the inline line comment
+            commentsToKeep = currentComments.slice(1);
+        }
+    }
+
+    // If we still have comments after filtering, use removed element's whitespace with filtered comments
+    if (commentsToKeep.length > 0) {
+        return produce(nextElement, draft => {
+            draft.prefix = {
+                ...removedPrefix,
+                comments: commentsToKeep
+            };
+        });
+    }
+
+    // No comments left after filtering, use removed element's prefix entirely
+    return produce(nextElement, draft => {
+        draft.prefix = removedPrefix;
+    });
+}

rewrite-javascript/rewrite/src/javascript/migrate/es6/index.ts

@@ -15,3 +15,4 @@
  */
 
 export {ModernizeOctalLiterals} from "./modernize-octal-literals";
+export {RemoveDuplicateObjectKeys} from "./remove-duplicate-object-keys";

rewrite-javascript/rewrite/src/javascript/migrate/es6/modernize-octal-literals.ts

@@ -29,7 +29,7 @@ export class ModernizeOctalLiterals extends Recipe {
     async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
         return new class extends JavaScriptVisitor<ExecutionContext> {
 
-            protected async visitLiteral(literal: J.Literal, p: ExecutionContext): Promise<J | undefined> {
+            protected async visitLiteral(literal: J.Literal, _ctx: ExecutionContext): Promise<J | undefined> {
                 // Only process numeric literals
                 if (typeof literal.value !== 'number') {
                     return literal;

rewrite-javascript/rewrite/src/javascript/migrate/es6/remove-duplicate-object-keys.ts

@@ -0,0 +1,137 @@
+/*
+ * Copyright 2025 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.
+ */
+
+import {Recipe} from "../../../recipe";
+import {TreeVisitor} from "../../../visitor";
+import {ExecutionContext} from "../../../execution";
+import {JavaScriptVisitor} from "../../visitor";
+import {J} from "../../../java";
+import {JS} from "../../tree";
+import {produce} from "immer";
+import {applyRemovedElementPrefix} from "../../../java/formatting-utils";
+
+export class RemoveDuplicateObjectKeys extends Recipe {
+    name = "org.openrewrite.javascript.migrate.es6.remove-duplicate-object-keys";
+    displayName = "Remove duplicate object keys";
+    description = "Remove duplicate keys in object literals, keeping only the last occurrence (last-wins semantics).";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+
+            protected async visitNewClass(newClass: J.NewClass, ctx: ExecutionContext): Promise<J | undefined> {
+                newClass = await super.visitNewClass(newClass, ctx) as J.NewClass;
+
+                // Only process object literals (NewClass with body but no class or arguments)
+                if (!newClass.body || newClass.class || (newClass.arguments?.elements && newClass.arguments.elements.length > 0)) {
+                    return newClass;
+                }
+
+                const statements = newClass.body.statements;
+                if (!statements || statements.length === 0) {
+                    return newClass;
+                }
+
+                // Build a map of property names to their last occurrence index
+                const propertyNameToLastIndex = new Map<string, number>();
+                const propertyNames: (string | null)[] = [];
+
+                for (let i = 0; i < statements.length; i++) {
+                    const stmt = statements[i];
+                    if (stmt.element.kind === JS.Kind.PropertyAssignment) {
+                        const prop = stmt.element as JS.PropertyAssignment;
+                        const propName = this.getPropertyName(prop);
+                        propertyNames.push(propName);
+
+                        if (propName !== null) {
+                            propertyNameToLastIndex.set(propName, i);
+                        }
+                    } else {
+                        propertyNames.push(null);
+                    }
+                }
+
+                // Check if there are any duplicates to remove
+                const indicesToRemove = new Set<number>();
+                for (let i = 0; i < propertyNames.length; i++) {
+                    const propName = propertyNames[i];
+                    if (propName !== null) {
+                        const lastIndex = propertyNameToLastIndex.get(propName)!;
+                        if (i < lastIndex) {
+                            indicesToRemove.add(i);
+                        }
+                    }
+                }
+
+                if (indicesToRemove.size === 0) {
+                    return newClass;
+                }
+
+                // Remove duplicate properties and adjust prefixes
+                return produce(newClass, draft => {
+                    const filteredStatements: typeof statements = [];
+                    let removedElement: J | undefined = undefined;
+
+                    for (let i = 0; i < statements.length; i++) {
+                        if (indicesToRemove.has(i)) {
+                            // Track the first removed element
+                            if (!removedElement && statements[i].element) {
+                                removedElement = statements[i].element;
+                            }
+                            continue;
+                        }
+
+                        const stmt = statements[i];
+
+                        // If we removed previous elements, apply the removed element's prefix to this one
+                        if (removedElement) {
+                            const adjustedElement = applyRemovedElementPrefix(removedElement, stmt.element);
+                            filteredStatements.push({
+                                ...stmt,
+                                element: adjustedElement
+                            });
+                            removedElement = undefined;
+                        } else {
+                            filteredStatements.push(stmt);
+                        }
+                    }
+
+                    draft.body!.statements = filteredStatements;
+                });
+            }
+
+            private getPropertyName(prop: JS.PropertyAssignment): string | null {
+                const name = prop.name.element;
+
+                // Handle identifier: { foo: 1 }
+                if (name.kind === J.Kind.Identifier) {
+                    return (name as J.Identifier).simpleName;
+                }
+
+                // Handle string literal: { "foo": 1 }
+                if (name.kind === J.Kind.Literal) {
+                    const literal = name as J.Literal;
+                    if (typeof literal.value === 'string') {
+                        return literal.value;
+                    }
+                }
+
+                // For computed properties { [expr]: 1 }, we can't statically determine the name
+                // So we return null and don't consider them for deduplication
+                return null;
+            }
+        }
+    }
+}

rewrite-javascript/rewrite/src/javascript/parser-utils.ts

@@ -355,7 +355,7 @@ export function checkSyntaxErrors(program: ts.Program, sourceFile: ts.SourceFile
     // checking Parsing and Syntax Errors
     let syntaxErrors : [errorMsg: string, errorCode: number][] = [];
     if (diagnostics.length > 0) {
-        const errors = diagnostics.filter(d =>  (d.category === ts.DiagnosticCategory.Error) && isCriticalDiagnostic(d.code));
+        const errors = diagnostics.filter(d =>  (d.category === ts.DiagnosticCategory.Error) && isCriticalDiagnostic(d.code, sourceFile));
         if (errors.length > 0) {
             syntaxErrors = errors.map(e => {
                 let errorMsg;
@@ -385,10 +385,9 @@ const additionalCriticalCodes = new Set([
 const excludedCodes = new Set([
     1039, // Initializers are not allowed in ambient contexts.
     1064, // The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<{0}>'?
-    1101, // 'with' statements are not allowed in strict mode.
     1107, // Jump target cannot cross function boundary.
     1111, // Private field '{0}' must be declared in an enclosing class.
-    1121, // Octal literals are not allowed. Use the syntax '{0}'.
+    1117, // An object literal cannot have multiple properties with the same name.
     1155, // '{0}' declarations must be initialized.
     1166, // A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type.
     1170, // A computed property name in a type literal must refer to an expression whose type is a literal type or a 'unique symbol' type.
@@ -424,7 +423,25 @@ const excludedCodes = new Set([
     1432, // Top-level 'for await' loops are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', 'node16', 'node18', 'node20', 'nodenext', or 'preserve', and the 'target' option is set to 'es2017' or higher.
 ]);
 
-function isCriticalDiagnostic(code: number): boolean {
+// Errors to exclude only for JavaScript files (.js, .jsx, .mjs, .cjs)
+// TypeScript files (.ts, .tsx, .mts, .cts) should still report these as errors
+const jsOnlyExcludedCodes = new Set([
+    1101, // 'with' statements are not allowed in strict mode.
+    1121, // Octal literals are not allowed. Use the syntax '{0}'.
+    1125, // Hexadecimal digit expected.
+]);
+
+function isCriticalDiagnostic(code: number, sourceFile: ts.SourceFile): boolean {
+    // Check if this error should be excluded for JavaScript files
+    if (jsOnlyExcludedCodes.has(code)) {
+        const fileName = sourceFile.fileName.toLowerCase();
+        const isJavaScript = fileName.endsWith('.js') || fileName.endsWith('.jsx') ||
+                           fileName.endsWith('.mjs') || fileName.endsWith('.cjs');
+        if (isJavaScript) {
+            return false; // Not critical for JS files
+        }
+    }
+
     return (code > 1000 && code < 2000 && !excludedCodes.has(code)) || additionalCriticalCodes.has(code);
 }