biome style/useObjectSpread

• Rewriting Object.assign({}, foo) to {...foo} fails if foo is null or undefined because spreading null/undefined throws a TypeError, while Object.assign treats them as no-ops.
• If the first argument is not an empty object (e.g., Object.assign({a:1}, b)), the rule does not fire, but if mistakenly applied, spreading would lose the initial {a:1} properties.
• When Object.assign is used with a non-literal first argument like a variable (Object.assign(x, y)), spreading {...x, ...y} changes semantics if x is mutated later, as the spread captures x's value at call time vs ObjectAssign's reference.
• If sources contain getters, Object.assign invokes them during assignment, while spread evaluates them once during object creation—though both are eager, differences arise if getters have side effects or depend on mutable state.
• In non-object parameters (e.g., Object.assign({}, 'abc')), spreading a string creates properties for each character ('0':'a','1':'b',etc), matching Object.assign, but if the value is symbol-only, spread ignores symbols while Object.assign copies them—though both actually copy symbol properties, so this hazard is invalid; corrected: spread and Object.assign both copy symbol-enumerable properties identically.
• Comments attached to the Object.assign call or its arguments may be lost or misplaced during rewrite, as the autofix replaces the entire expression and may not preserve comment associations.
• If Object.assign is shadowed by a local variable (e.g., const ObjectAssign = Object.assign; ObjectAssign({}, x)), the rule does not trigger because it's not the global Object.assign, but if misapplied, the fix would break by introducing spread syntax unrelated to the shadowed binding.
• In strict mode, both behaviors are identical, but in sloppy mode, Object.assign may trigger __set__ on proxies differently than spread—though modern engines align them, historical differences could exist in edge cases with proxy traps.
• When the call is part of a larger expression (e.g., return Object.assign({}, x)), rewriting to return {...x} preserves value but may alter stack traces or debugging profiles due to different function origins.
• If the sources include expressions with side effects (e.g., Object.assign({}, f(), g())), the evaluation order of f() and g() is left-to-right in both Object.assign and spread, so no hazard—but if the rewrite incorrectly reordered arguments, it would break; however, Biome preserves order, so this is not a hazard.

99

--- orig.js	2026-10-17 15:38:52.903212603 -0400
+++ fixed.js	2026-10-17 15:38:53.180208894 -0400
@@ -5,5 +5,5 @@
     return counter * 10;
   }
 };
-const result = Object.assign({}, src);
+const result = ({...src,});
 console.log('result.value:', result.value, 'counter:', counter);

result.value: 10 counter: 1

a=1

--- orig.js	2026-10-17 15:38:53.564203745 -0400
+++ fixed.js	2026-10-17 15:38:53.835200111 -0400
@@ -2,6 +2,6 @@
 regex.lastIndex = 0;
 const str = 'aa';
 const match1 = regex.exec(str);
-const obj = Object.assign({}, { pattern: regex });
+const obj = ({pattern: regex ,});
 const match2 = regex.exec(str);
 console.log('match1:', match1 ? match1[0] : null, 'match2:', match2 ? match2[0] : null);

match1: a match2: a

--- orig.js	2026-10-17 15:38:54.001197886 -0400
+++ fixed.js	2026-10-17 15:38:54.279194144 -0400
@@ -1,5 +1,5 @@
 let order = '';
 function f() { order += 'f'; return { x: 1 }; }
 function g() { order += 'g'; return { y: 2 }; }
-const result = Object.assign({}, f(), g());
+const result = ({...f(),...g(),});
 console.log('order:', order, 'result:', JSON.stringify(result));

order: fg result: {"x":1,"y":2}

--- orig.js	2026-10-17 15:38:54.446191896 -0400
+++ fixed.js	2026-10-17 15:38:54.724188155 -0400
@@ -8,6 +8,6 @@
     // Stack trace differs based on whether we use Object.assign or spread
     console.log(e.stack.split('\n')[1].trim());
   }
-  return Object.assign({}, getObj());
+  return ({...getObj(),});
 }
 wrapper();

at wrapper (file:///home/sun/dev/diaghunt/runs/2026-10-17T19-38-41-627Z-2c90-biome-style_useObjectSpread/r1-p006/orig.js:6:11)

result.a: 1 result.b: 2 result.c: 3

--- orig.js	2026-10-17 15:38:55.102183062 -0400
+++ fixed.js	2026-10-17 15:38:55.368179468 -0400
@@ -1,7 +1,7 @@
 for (var i = 0; i < 2; i++) {
   var obj = { x: i };
   if (i === 0) {
-    var copied = Object.assign({}, obj);
+    var copied = ({...obj,});
   }
   obj.x = 99;
 }

copied.x: 0

IIFE ran
object

99 true
1 true

undefined

--- orig.js	2026-10-17 15:39:01.053101892 -0400
+++ fixed.js	2026-10-17 15:39:01.315098274 -0400
@@ -1,6 +1,6 @@
 for (var i = 0; i < 2; i++) {
   var obj = {value: i};
-  const copy = Object.assign({}, obj);
+  const copy = ({...obj,});
   obj.value += 10;
   console.log(copy.value)
 }

0
1

--- orig.js	2026-10-17 15:39:01.480095995 -0400
+++ fixed.js	2026-10-17 15:39:01.725092611 -0400
@@ -1,6 +1,6 @@
 function getObj() { return {x: 1} }
 function test() {
-  return Object.assign({}, getObj());
+  return ({...getObj(),});
 }
 try { test() } catch(e) {
   console.log(e.stack.split('\n')[1].trim())

--- orig.js	2026-10-17 15:39:01.931089766 -0400
+++ fixed.js	2026-10-17 15:39:02.198086068 -0400
@@ -1,5 +1,5 @@
 const obj = {val: 1, getVal() { return this.val }};
 const fn = obj.getVal;
 console.log(fn.call(obj))
-const copied = Object.assign({}, obj);
+const copied = ({...obj,});
 console.log(copied.getVal?.call(obj))

1
1