biome style/useObjectSpread

• If the first argument is not a literal {} but a variable or expression that evaluates to an empty object, the fix incorrectly assumes it is a literal and removes it, altering behavior.
• If Object.assign is called via a different reference (e.g., const assign = Object.assign; assign({}, foo)), the fix does not apply and may leave unsafe code unchanged, but if misapplied, it would break due to missing context.
• If the first argument is {} but followed by non-object primitives (e.g., Object.assign({}, null, foo)), the spread fix may throw at runtime because spreading null/undefined is invalid, whereas Object.assign coerces them.
• If the Object.assign call is inside a larger expression and the fix removes parentheses needed for grouping (e.g., return Object.assign({}, foo); → return {...foo}; is safe, but (Object.assign({}, foo)) → ({...foo}) may be needed in some contexts like JSX props), the fix might omit necessary parentheses.
• If the code relies on the side effect of Object.assign defining properties on the first argument (even if it's {}), and that object is later used elsewhere, the fix changes when the object is created (in-place vs new), potentially causing aliasing issues.
• If the first argument {} is actually a destructured or computed property in an object literal (e.g., {[k]: Object.assign({}, foo)}), the fix could produce invalid syntax or change evaluation order.
• If the Object.assign call is in a loop or frequently executed path and the environment lacks spread support (e.g., IE without transpilation), the fix may introduce syntax errors in older environments.
• If the arguments after the first include getters or have side effects, the evaluation order of spreading vs Object.assign is the same (left-to-right), so no issue, but if the fix were to reorder args (it doesn't), it would matter—however, Biome's fix preserves order.
• If the code contains trailing comments on the Object.assign line, the fix might discard them if not properly preserved during replacement.
• If the first argument {} is actually part of a larger object literal spread (e.g., {...other, ...Object.assign({}, foo)}), replacing the inner call could break nesting or change the resulting object structure due to duplicate key handling.

--- orig.js	2026-10-17 17:06:51.040241668 -0400
+++ fixed.js	2026-10-17 17:06:51.319244699 -0400
@@ -1,6 +1,6 @@
 let result
 (() => {
-  const r = Object.assign({}, {x: 1})
+  const r = ({x: 1,})
   return r.x
 })().then(v => {
   console.log('result:', v)

--- orig.js	2026-10-17 17:06:51.488246536 -0400
+++ fixed.js	2026-10-17 17:06:51.772249622 -0400
@@ -1,5 +1,5 @@
 // Setup
 const input = {a: 1}
 // Transform
-const out = /* comment */Object.assign(/* another */{}, input)// end
+const out = /* comment */({...input,})// end
 console.log(out.a)

1

--- orig.js	2026-10-17 17:06:51.978251860 -0400
+++ fixed.js	2026-10-17 17:06:52.252254837 -0400
@@ -1,6 +1,6 @@
 function f() {
   for (var i = 0; i < 2; i++) {
-    var tmp = Object.assign({}, {val: i})
+    var tmp = ({val: i,})
     console.log(tmp.val)
   }
   console.log(typeof tmp)

0
1
object

--- orig.js	2026-10-17 17:06:52.418256640 -0400
+++ fixed.js	2026-10-17 17:06:52.675259432 -0400
@@ -1,6 +1,6 @@
 let data = {prop: 'outer'}
 {
-  let data = Object.assign({}, {inner: 'value'})
+  let data = ({inner: 'value',})
   console.log(data.prop, data.inner)
 }
 console.log(data.prop)

undefined value
outer

--- orig.js	2026-10-17 17:06:52.844261268 -0400
+++ fixed.js	2026-10-17 17:06:53.121264276 -0400
@@ -1,5 +1,5 @@
 let seq = []
 const obj1 = {get a(){seq.push(1); return 1}}
 const obj2 = {get b(){seq.push(2); return 2}}
-const res = Object.assign({}, obj1, obj2)
+const res = ({...obj1,...obj2,})
 console.log('seq:', seq.join(', '), 'res:', JSON.stringify(res))

seq: 1, 2 res: {"a":1,"b":2}

--- orig.js	2026-10-17 17:06:53.297266188 -0400
+++ fixed.js	2026-10-17 17:06:53.576269218 -0400
@@ -2,11 +2,11 @@
   static baseProp = 'base'
 }
 class Derived extends Base {
-  static staticProp = Object.assign({}, {derived: true})
+  static staticProp = ({derived: true,})
   static {
     console.log(Base.baseProp, Derived.staticProp.derived)
   }
-  #private = Object.assign({}, {secret: 42})
+  #private = ({secret: 42,})
   constructor() {
     super()
     console.log(this.#private.secret)

base true
42

--- orig.js	2026-10-17 17:06:53.749271097 -0400
+++ fixed.js	2026-10-17 17:06:54.033274181 -0400
@@ -1,7 +1,7 @@
 start: {
   if (true) {
     function helper() {
-      return Object.assign({}, {flag: true})
+      return ({flag: true,})
     }
     const h = helper()
     console.log(h.flag)
@@ -10,7 +10,7 @@
   switch (0) {
     case 0:
       function caseFn() {
-        return Object.assign({}, {case: 0})
+        return ({case: 0,})
       }
       console.log(caseFn().case)
       break

true

--- orig.js	2026-10-17 17:06:59.358331965 -0400
+++ fixed.js	2026-10-17 17:06:59.630334914 -0400
@@ -4,5 +4,5 @@
   configurable: true
 });
 console.log('before:', typeof target.prop);
-Object.assign({}, target); // triggers rule
+({...target,}); // triggers rule
 console.log('after:', typeof target.prop);

GET
before: number
GET
after: number

--- orig.js	2026-10-17 17:06:59.800336757 -0400
+++ fixed.js	2026-10-17 17:07:00.080339793 -0400
@@ -2,6 +2,6 @@
 arr[1] = 'present';
 console.log('sparse length:', arr.length);
 console.log('sparse [1]:', arr[1]);
-const copy = Object.assign({}, arr); // triggers rule
+const copy = ({...arr,}); // triggers rule
 console.log('copy length:', copy.length);
 console.log('copy [1]:', copy[1]);

sparse length: 3
sparse [1]: present
copy length: undefined
copy [1]: present

result.x: 1

--- orig.js	2026-10-17 17:07:00.481344141 -0400
+++ fixed.js	2026-10-17 17:07:00.740346948 -0400
@@ -1,6 +1,6 @@
 let key = 'dynamic';
 const obj = {
-  [key]: Object.assign({}, {a: 1}) // triggers rule
+  [key]: ({a: 1,}) // triggers rule
 };
 console.log(obj.dynamic.a);
 key = 'changed';

1
not present

shared.x after assign: 1
shared.y after second assign: 2

--- orig.js	2026-10-17 17:07:01.190351826 -0400
+++ fixed.js	2026-10-17 17:07:01.460354753 -0400
@@ -1,6 +1,6 @@
 function test(a, b, c) {
   console.log('args length:', arguments.length);
-  const copied = Object.assign({}, arguments); // triggers rule
+  const copied = ({...arguments,}); // triggers rule
   console.log('copied 0:', copied[0]);
   return copied;
 }

args length: 3
copied 0: 10
result 2: 30

--- orig.js	2026-10-17 17:07:01.626356552 -0400
+++ fixed.js	2026-10-17 17:07:01.907359597 -0400
@@ -1,7 +1,7 @@
 let obj = {x: 1};
 if (true) {
   let obj = {y: 2}; // inner obj
-  Object.assign({}, obj); // triggers rule, copies inner {y:2}
+  ({...obj,}); // triggers rule, copies inner {y:2}
   console.log('inner:', obj.y);
 }
 console.log('outer:', obj.x); // outer obj unchanged

inner: 2
outer: 1

--- orig.js	2026-10-17 17:07:02.074361407 -0400
+++ fixed.js	2026-10-17 17:07:02.348364376 -0400
@@ -2,7 +2,7 @@
   throw new TypeError('intentional');
 }
 try {
-  Object.assign({}, {a: risky()}); // triggers rule, risky() throws
+  ({a: risky(),}); // triggers rule, risky() throws
 } catch (e) {
   console.log('caught:', e.name, e.message);
 }

caught: TypeError intentional
continued