eslint prefer-exponentiation-operator

• If either operand contains side effects (e.g., function calls), changing from Math.pow(a(), b()) to a() ** b() may alter evaluation order if the language specification differed—though both evaluate left-to-right, the rewrite assumes identical semantics and any future spec change could break equivalence.
• If 'Math' is rebound in the current scope (e.g., var Math = {};), the original code would reference the binding while the fix assumes the global Math, potentially causing a ReferenceError or wrong value.
• If 'pow' is rebound as a property of Math (e.g., Math.pow = function(){return 0;}), the fix bypasses the overridden method and uses the built-in operator, altering behavior.
• If the code relies on Math.pow's specific handling of NaN or signed zeros (though ** matches), any future divergence in engine implementations could cause subtle differences.
• If the expression includes decorators, annotations, or non-standard syntax that attaches meaning to the call site, stripping the call form could lose metadata.
• If the codebase uses a transpiler that treats Math.pow specially (e.g., for polyfilling older engines), replacing it with ** might interfere with the transpiler's output.
• If a comment is attached to the Math token or the dot (e.g., Math/*ignore*/.pow(2,3)), the autofix may discard the comment when rewriting to 2 ** 3.
• If the arguments are expressions that themselves contain commas (e.g., Math.pow(a, b, c)), the rule does not fire because the shape is invalid, but if mistakenly applied, the fix would produce a SyntaxError.
• If the code is parsed in strict mode and Math is not defined, the original throws a ReferenceError; the fix would throw a ReferenceError earlier when evaluating the left-hand side if it is an undefined variable, changing timing but not outcome.
• If the exponentiation operator is used in a context where an expression is expected but the surrounding code relies on the call being a valid LeftHandSideExpression (e.g., in destructuring like [Math.pow] = []), the fix breaks because ** cannot appear there.

Success: 8

--- orig.js	2026-10-22 14:26:47.923829742 -0400
+++ fixed.js	2026-10-22 14:26:50.545779858 -0400
@@ -1,4 +1,4 @@
-console.log(Math.pow(-0, -1)); // Should be -Infinity
+console.log((-0)**-1); // Should be -Infinity
 console.log((-0) ** (-1));     // Same currently, but testing equivalence
-console.log(Math.pow(NaN, 0));   // Should be 1
+console.log(NaN**0);   // Should be 1
 console.log(NaN ** 0);         // Same currently

-Infinity
-Infinity
1
1

a: 2 b: 3 c: 4

--- orig.js	2026-10-22 14:26:47.924829722 -0400
+++ fixed.js	2026-10-22 14:26:51.775756714 -0400
@@ -6,7 +6,7 @@
 foo().then(r => console.log('Async result:', r));
 
 function* gen() {
-  yield Math.pow(2, 3);
+  yield 2**3;
 }
 const g = gen();
 console.log('Generator first yield:', g.next().value);

Generator first yield: 8
Async result: 8

Local Math.pow(2,3): 6
Broken fix (2**3): 8

--- orig.js	2026-10-22 14:26:47.925829703 -0400
+++ fixed.js	2026-10-22 14:26:51.413763510 -0400
@@ -3,4 +3,4 @@
 console.log('obj.Math.pow(2,3):', obj.Math.pow(2, 3));
 // Rule would see obj.Math.pow and NOT fire (not direct Math)
 // So no rewrite happens here.
-console.log('Global Math.pow(2,3):', Math.pow(2, 3));
+console.log('Global Math.pow(2,3):', 2**3);

obj.Math.pow(2,3): 5
Global Math.pow(2,3): 8

--- orig.js	2026-10-22 14:26:49.998790189 -0400
+++ fixed.js	2026-10-22 14:26:53.768719579 -0400
@@ -1,10 +1,10 @@
 const val = { valueOf: () => 2, toString: () => '2' };
-console.log('Math.pow(val, 3):', Math.pow(val, 3));
+console.log('Math.pow(val, 3):', val**3);
 console.log('val ** 3:', val ** 3);
 
 const sym = Symbol(1);
 try {
-  console.log(Math.pow(sym, 2));
+  console.log(sym**2);
 } catch (e) {
   console.log('Math.pow(Symbol) error:', e.name);
 }

Math.pow(val, 3): 8
val ** 3: 8
Math.pow(Symbol) error: TypeError
Symbol ** error: TypeError

--- orig.js	2026-10-22 14:26:50.434781954 -0400
+++ fixed.js	2026-10-22 14:26:53.066732602 -0400
@@ -7,5 +7,5 @@
 // Direct call that rule would fire on
 const base = 2;
 exp = 3;
-console.log('Math.pow(base,exp):', Math.pow(base, exp));
+console.log('Math.pow(base,exp):', base**exp);
 console.log('base ** exp:', base ** exp);

x?.prop?.Math?.pow?.(2,3): undefined
x?.prop?.Math?.pow?.(2,3): 8
Math.pow(base,exp): 8
base ** exp: 8

--- orig.js	2026-10-22 14:27:00.173603221 -0400
+++ fixed.js	2026-10-22 14:27:02.863555701 -0400
@@ -3,6 +3,6 @@
   x++;
   return x;
 };
-console.log(Math.pow(inc(), inc()));
+console.log(inc()**inc());
 x = 0;
 console.log(inc() ** inc());

1
1

--- orig.js	2026-10-22 14:27:00.174603203 -0400
+++ fixed.js	2026-10-22 14:27:02.980553647 -0400
@@ -1,6 +1,6 @@
 let val = null;
 try {
-  console.log(Math.pow(val, 2));
+  console.log(val**2);
 } catch (e) {
   console.log(e.name + ': ' + e.message);
 }

0
NaN

--- orig.js	2026-10-22 14:27:00.174603203 -0400
+++ fixed.js	2026-10-22 14:27:02.947554227 -0400
@@ -1,5 +1,5 @@
 Math.pow = function(base, exp) { return base + exp; };
-console.log(Math.pow(2, 3));
+console.log(2**3);
 depth = 0;
 while (depth < 1) {
   console.log(2 ** 3);

5
8

--- orig.js	2026-10-22 14:27:00.175603185 -0400
+++ fixed.js	2026-10-22 14:27:02.896555122 -0400
@@ -1,4 +1,4 @@
 const arr = Array(3);
 arr[2] = 2;
-console.log(Math.pow(arr[0], arr[2]));
+console.log(arr[0]**arr[2]);
 console.log(arr[0] ** arr[2]);

NaN
NaN

--- orig.js	2026-10-22 14:27:00.176603168 -0400
+++ fixed.js	2026-10-22 14:27:02.871555561 -0400
@@ -1,6 +1,6 @@
 function test(a = 2, b = 3) {
   console.log(arguments.length);
-  console.log(Math.pow(a, b));
+  console.log(a**b);
 }
 test();
 function test2() {

0
8
0
8

No trigger - comma in args invalid for Math.pow

--- orig.js	2026-10-22 14:27:02.739557878 -0400
+++ fixed.js	2026-10-22 14:27:05.358512341 -0400
@@ -2,7 +2,7 @@
 console.log(typeof exp);
 var base = 2;
 var exp = 3;
-console.log(Math.pow(base, exp));
+console.log(base**exp);
 base = 4;
 exp = 2;
 console.log(base ** exp);

undefined
undefined
8
16