biome nursery/noUnnecessaryTemplateExpression

• Rewriting `${'hello'}` to 'hello' changes behavior if the code relies on the template literal being a distinct object identity (e.g., for === comparison with another template literal).
• Converting `${'a'}${'b'}` to 'a'+'b' may alter evaluation order if the original template was part of a larger expression where left-to-right timing mattered for side effects in surrounding expressions.
• If the template literal appears in a context expecting a TemplateLiteral type (e.g., tagged template inference), replacing it with a string literal breaks type checking in TypeScript.
• The autofix may incorrectly remove escaped characters like \n or \t within the string literals if they are present, altering the resulting string value.
• When the template literal is immediately followed by a plus (+) without space, rewriting `'a'+'b'` could be misparsed as part of a larger concatenation chain due to operator precedence.
• Comments inside the template literal (e.g., `${'hello' /* comment */}`) would be lost during the rewrite since string literals do not preserve internal comments.
• If the string literal contains a line terminator (e.g., `${'a\nb'}`), rewriting it as a plain string literal may break if the surrounding code depends on the template literal's multi-line nature for ASI or parsing.
• In strict mode, if the original template literal was used in an eval-like context, replacing it with a string literal could change how the string is interpreted due to differing escape handling.
• The fix assumes all interpolated parts are pure string literals; if any interpolation is actually a non-literal (e.g., due to macro expansion), the rewrite would incorrectly remove necessary template syntax.
• When the template literal is part of a sequence expression or comma operator, rewriting it may change how the expression is parsed or optimized by minifiers.
• If the template literal is used as a property key in an object literal, rewriting it to a string literal may cause a syntax error if the original relied on template literal flexibility (though rare, as keys are coerced).
• The autofix may insert unnecessary parentheses around the rewritten expression if not carefully formatted, potentially altering precedence in edge cases involving exponentiation or nullish coalescing.

--- orig.js	2026-10-17 16:47:42.635184249 -0400
+++ fixed.js	2026-10-17 16:47:42.918190776 -0400
@@ -1,4 +1,4 @@
 let x = 0;
 const log = v => { console.log('log:', v); return ++x; };
-expr = (log(1), `${'a'}${'b'}`, log(2));
+expr = (log(1), "ab", log(2));
 console.log('Result:', expr);

log: 1
log: 2

Tagged result: {"raw":["","",""],"cooked":["hello","world"]}

--- orig.js	2026-10-17 16:47:43.314199901 -0400
+++ fixed.js	2026-10-17 16:47:43.587206189 -0400
@@ -1,5 +1,5 @@
 let evalOrder = [];
 const push = v => { evalOrder.push(v); return v; };
-const expr = (push(1), `${'a'}${'b'}`, push(2), push(3));
+const expr = (push(1), "ab", push(2), push(3));
 console.log('Eval order:', evalOrder.join(','));
 console.log('Expr value:', expr);

Eval order: 1,2,3
Expr value: 3

--- orig.js	2026-10-17 16:47:43.812211373 -0400
+++ fixed.js	2026-10-17 16:47:44.086217682 -0400
@@ -1,5 +1,5 @@
 const obj = {
-  [`${'key'}${'name'}`]: 'value'
+  ["keyname"]: 'value'
 };
 console.log('Key exists:', Object.hasOwn(obj, 'keyname'));
 console.log('Value:', obj.keyname);

Key exists: true
Value: value

--- orig.js	2026-10-17 16:47:44.265221801 -0400
+++ fixed.js	2026-10-17 16:47:44.535228014 -0400
@@ -1,5 +1,5 @@
 const protoObj = { __proto__: null };
-const key = `${'__proto__'}${'sub'}`;
+const key = "__proto__sub";
 try {
   protoObj[key] = 'should not set proto';
   console.log('Assignment succeeded, proto unchanged:', protoObj.__proto__ === null);

Assignment succeeded, proto unchanged: false