From 4c44ba015ef1e30bda0fcceb89343f2a1ec7b04b Mon Sep 17 00:00:00 2001 From: burrows99 Date: Sun, 22 Nov 2026 18:58:00 +0000 Subject: [PATCH] Keep side effects in sequence operands when folding constants Babel evaluates a sequence expression to its last operand, so constantFoldingPlugin treated a test like `(n++, false)` as a constant and dropped `n++`. Minifiers join statements into an `if` test this way, so `if(n++,"production"!==process.env.NODE_ENV)` in a prebuilt package lost its increment in production builds. Treat update, delete, new, await, yield and tagged template expressions as unsafe to fold, like calls and assignments already are. --- .../__tests__/constant-folding-plugin-test.js | 33 +++++++++++++++++++ .../src/constant-folding-plugin.js | 23 +++++++------ 2 files changed, 46 insertions(+), 10 deletions(-) diff --git a/packages/metro-transform-plugins/src/__tests__/constant-folding-plugin-test.js b/packages/metro-transform-plugins/src/__tests__/constant-folding-plugin-test.js index 184ea1cc22..8ffc646086 100644 --- a/packages/metro-transform-plugins/src/__tests__/constant-folding-plugin-test.js +++ b/packages/metro-transform-plugins/src/__tests__/constant-folding-plugin-test.js @@ -437,6 +437,39 @@ describe('constant expressions', () => { compare([constantFoldingPlugin], code, expected); }); + test('does not drop side effects from the leading operands of a sequence', () => { + const code = ` + if ((i++, false)) { + a(); + } + var b = (delete o.x, true) ? 1 : 2; + var c = (new Foo(), null) || 3; + var d = (--j, 1) + 2; + var h = (tag\`x\`, 0) || 4; + async function e() { + if ((await f, false)) {} + } + function* g() { + if ((yield, false)) {} + } + export {e, g}; + `; + + compare([constantFoldingPlugin], code, code); + }); + + test('folds a sequence whose leading operands have no side effects', () => { + const code = ` + var a = (0, 'production' !== 'production') ? 1 : 2; + `; + + const expected = ` + var a = 2; + `; + + compare([constantFoldingPlugin], code, expected); + }); + test('does not fold arithmetic on destructured object bindings', () => { const code = ` const O = {e: 80}; diff --git a/packages/metro-transform-plugins/src/constant-folding-plugin.js b/packages/metro-transform-plugins/src/constant-folding-plugin.js index d91beef7b6..ed4056b766 100644 --- a/packages/metro-transform-plugins/src/constant-folding-plugin.js +++ b/packages/metro-transform-plugins/src/constant-folding-plugin.js @@ -14,15 +14,12 @@ import type {NodePath, VisitNode, Visitor} from '@babel/traverse'; import typeof Traverse from '@babel/traverse'; import type { ArrowFunctionExpression as BabelNodeArrowFunctionExpression, - AssignmentExpression as BabelNodeAssignmentExpression, BinaryExpression as BabelNodeBinaryExpression, - CallExpression as BabelNodeCallExpression, ConditionalExpression as BabelNodeConditionalExpression, FunctionDeclaration as BabelNodeFunctionDeclaration, FunctionExpression as BabelNodeFunctionExpression, IfStatement as BabelNodeIfStatement, LogicalExpression as BabelNodeLogicalExpression, - OptionalCallExpression as BabelNodeOptionalCallExpression, Program as BabelNodeProgram, UnaryExpression as BabelNodeUnaryExpression, } from '@babel/types'; @@ -47,13 +44,7 @@ export default function constantFoldingPlugin(context: { value: unknown, } { const state = {safe: true}; - const unsafe = ( - path: - | NodePath - | NodePath - | NodePath, - state: {safe: boolean}, - ) => { + const unsafe = (path: NodePath<>, state: {safe: boolean}) => { state.safe = false; }; @@ -80,6 +71,18 @@ export default function constantFoldingPlugin(context: { * resulting in the expression call being skipped. */ OptionalCallExpression: unsafe, + // Babel evaluates a sequence to its last operand, so side effects in + // the leading operands (e.g. `(i++, false)`) would otherwise be lost. + AwaitExpression: unsafe, + NewExpression: unsafe, + TaggedTemplateExpression: unsafe, + UpdateExpression: unsafe, + YieldExpression: unsafe, + UnaryExpression(path, state) { + if (path.node.operator === 'delete') { + state.safe = false; + } + }, }, state, );