feat(compiler): Implement constant propagation for template literals

compiler/packages/babel-plugin-react-compiler/src/Optimization/ConstantPropagation.ts

@@ -509,6 +509,73 @@ function evaluateInstruction(
       }
       return null;
     }
+    case 'TemplateLiteral': {
+      if (value.subexprs.length === 0) {
+        const result: InstructionValue = {
+          kind: 'Primitive',
+          value: value.quasis.map(q => q.cooked).join(''),
+          loc: value.loc,
+        };
+        instr.value = result;
+        return result;
+      }
+
+      if (value.subexprs.length !== value.quasis.length - 1) {
+        return null;
+      }
+
+      if (value.quasis.some(q => q.cooked === undefined)) {
+        return null;
+      }
+
+      let quasiIndex = 0;
+      let resultString = value.quasis[quasiIndex].cooked as string;
+      ++quasiIndex;
+
+      for (const subExpr of value.subexprs) {
+        const subExprValue = read(constants, subExpr);
+        if (!subExprValue || subExprValue.kind !== 'Primitive') {
+          return null;
+        }
+
+        const expressionValue = subExprValue.value;
+        if (
+          typeof expressionValue !== 'number' &&
+          typeof expressionValue !== 'string' &&
+          typeof expressionValue !== 'boolean' &&
+          !(typeof expressionValue === 'object' && expressionValue === null)
+        ) {
+          // value is not supported (function, object) or invalid (symbol), or something else
+          return null;
+        }
+
+        const suffix = value.quasis[quasiIndex].cooked;
+        ++quasiIndex;
+
+        if (suffix === undefined) {
+          return null;
+        }
+
+        /*
+         * Spec states that concat calls ToString(argument) internally on its parameters
+         * -> we don't have to implement ToString(argument) ourselves and just use the engine implementation
+         * Refs:
+         *  - https://tc39.es/ecma262/2024/#sec-tostring
+         *  - https://tc39.es/ecma262/2024/#sec-string.prototype.concat
+         *  - https://tc39.es/ecma262/2024/#sec-template-literals-runtime-semantics-evaluation
+         */
+        resultString = resultString.concat(expressionValue as string, suffix);
+      }
+
+      const result: InstructionValue = {
+        kind: 'Primitive',
+        value: resultString,
+        loc: value.loc,
+      };
+
+      instr.value = result;
+      return result;
+    }
     case 'LoadLocal': {
       const placeValue = read(constants, value.place);
       if (placeValue !== null) {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/constant-propagation-template-literal.expect.md

@@ -0,0 +1,136 @@
+
+## Input
+
+```javascript
+import {Stringify, identity} from 'shared-runtime';
+
+function foo() {
+  try {
+    identity(`${Symbol('0')}`); // Uncaught TypeError: Cannot convert a Symbol value to a string (leave as is)
+  } catch {}
+
+  return (
+    <Stringify
+      value={[
+        `` === '',
+        `\n` === '\n',
+        `a\nb`,
+        `\n`,
+        `a${1}b`,
+        ` abc \u0041\n\u000a\ŧ`,
+        `abc${1}def`,
+        `abc${1}def${2}`,
+        `abc${1}def${2}ghi`,
+        `a${1 + 3}b${``}c${'d' + `e${2 + 4}f`}`,
+        `1${2}${Math.sin(0)}`,
+        `${NaN}`,
+        `${Infinity}`,
+        `${-Infinity}`,
+        `${Number.MAX_SAFE_INTEGER}`,
+        `${Number.MIN_SAFE_INTEGER}`,
+        `${Number.MAX_VALUE}`,
+        `${Number.MIN_VALUE}`,
+        `${-0}`,
+        `
+        `,
+        `${{}}`,
+        `${[1, 2, 3]}`,
+        `${true}`,
+        `${false}`,
+        `${null}`,
+        `${undefined}`,
+        `123456789${0}`,
+        `${0}123456789`,
+        `${0}123456789${0}`,
+        `${0}1234${5}6789${0}`,
+        `${0}1234${`${0}123456789${`${0}123456789${0}`}`}6789${0}`,
+        `${0}1234${`${0}123456789${`${identity(0)}`}`}6789${0}`,
+        `${`${`${`${0}`}`}`}`,
+        `${`${`${`${''}`}`}`}`,
+        `${`${`${`${identity('')}`}`}`}`,
+      ]}
+    />
+  );
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: foo,
+  params: [],
+  isComponent: false,
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { Stringify, identity } from "shared-runtime";
+
+function foo() {
+  const $ = _c(1);
+  try {
+    identity(`${Symbol("0")}`);
+  } catch {}
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = (
+      <Stringify
+        value={[
+          true,
+          true,
+
+          "a\nb",
+          "\n",
+          "a1b",
+          " abc A\n\n\u0167",
+          "abc1def",
+          "abc1def2",
+          "abc1def2ghi",
+          "a4bcde6f",
+          `1${2}${Math.sin(0)}`,
+          `${NaN}`,
+          `${Infinity}`,
+          `${-Infinity}`,
+          `${Number.MAX_SAFE_INTEGER}`,
+          `${Number.MIN_SAFE_INTEGER}`,
+          `${Number.MAX_VALUE}`,
+          `${Number.MIN_VALUE}`,
+          "0",
+          "\n        ",
+
+          `${{}}`,
+          `${[1, 2, 3]}`,
+          "true",
+          "false",
+          "null",
+          `${undefined}`,
+          "1234567890",
+          "0123456789",
+          "01234567890",
+          "01234567890",
+          "0123401234567890123456789067890",
+          `${0}1234${`${0}123456789${`${identity(0)}`}`}6789${0}`,
+          "0",
+          "",
+          `${`${`${`${identity("")}`}`}`}`,
+        ]}
+      />
+    );
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  return t0;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: foo,
+  params: [],
+  isComponent: false,
+};
+
+```
+
+### Eval output
+(kind: ok) <div>{"value":[true,true,"a\nb","\n","a1b"," abc A\n\nŧ","abc1def","abc1def2","abc1def2ghi","a4bcde6f","120","NaN","Infinity","-Infinity","9007199254740991","-9007199254740991","1.7976931348623157e+308","5e-324","0","\n        ","[object Object]","1,2,3","true","false","null","undefined","1234567890","0123456789","01234567890","01234567890","0123401234567890123456789067890","012340123456789067890","0","",""]}</div>

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/constant-propagation-template-literal.js

@@ -0,0 +1,56 @@
+import {Stringify, identity} from 'shared-runtime';
+
+function foo() {
+  try {
+    identity(`${Symbol('0')}`); // Uncaught TypeError: Cannot convert a Symbol value to a string (leave as is)
+  } catch {}
+
+  return (
+    <Stringify
+      value={[
+        `` === '',
+        `\n` === '\n',
+        `a\nb`,
+        `\n`,
+        `a${1}b`,
+        ` abc \u0041\n\u000a\ŧ`,
+        `abc${1}def`,
+        `abc${1}def${2}`,
+        `abc${1}def${2}ghi`,
+        `a${1 + 3}b${``}c${'d' + `e${2 + 4}f`}`,
+        `1${2}${Math.sin(0)}`,
+        `${NaN}`,
+        `${Infinity}`,
+        `${-Infinity}`,
+        `${Number.MAX_SAFE_INTEGER}`,
+        `${Number.MIN_SAFE_INTEGER}`,
+        `${Number.MAX_VALUE}`,
+        `${Number.MIN_VALUE}`,
+        `${-0}`,
+        `
+        `,
+        `${{}}`,
+        `${[1, 2, 3]}`,
+        `${true}`,
+        `${false}`,
+        `${null}`,
+        `${undefined}`,
+        `123456789${0}`,
+        `${0}123456789`,
+        `${0}123456789${0}`,
+        `${0}1234${5}6789${0}`,
+        `${0}1234${`${0}123456789${`${0}123456789${0}`}`}6789${0}`,
+        `${0}1234${`${0}123456789${`${identity(0)}`}`}6789${0}`,
+        `${`${`${`${0}`}`}`}`,
+        `${`${`${`${''}`}`}`}`,
+        `${`${`${`${identity('')}`}`}`}`,
+      ]}
+    />
+  );
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: foo,
+  params: [],
+  isComponent: false,
+};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/labeled-break-within-label-switch.expect.md

@@ -40,16 +40,16 @@ function useHook(cond) {
     log = [];
     switch (CONST_STRING0) {
       case CONST_STRING0: {
-        log.push(`@A`);
+        log.push("@A");
         bb0: {
           if (cond) {
             break bb0;
           }
 
-          log.push(`@B`);
+          log.push("@B");
         }
 
-        log.push(`@C`);
+        log.push("@C");
       }
     }
     $[0] = cond;

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/sequential-destructuring-assignment-to-scope-declarations.expect.md

@@ -97,7 +97,7 @@ function foo(name) {
   const t0 = `${name}!`;
   let t1;
   if ($[0] !== t0) {
-    t1 = { status: `<status>`, text: t0 };
+    t1 = { status: "<status>", text: t0 };
     $[0] = t0;
     $[1] = t1;
   } else {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/sequential-destructuring-both-mixed-local-and-scope-declaration.expect.md

@@ -102,7 +102,7 @@ function foo(name) {
   const t0 = `${name}!`;
   let t1;
   if ($[0] !== t0) {
-    t1 = { status: `<status>`, text: t0 };
+    t1 = { status: "<status>", text: t0 };
     $[0] = t0;
     $[1] = t1;
   } else {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/template-literal.expect.md

@@ -20,7 +20,7 @@ function componentB(props) {
 ```javascript
 function componentA(props) {
   let t = `hello ${props.a}, ${props.b}!`;
-  t = t + ``;
+  t = t + "";
   return t;
 }
 

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/unlabeled-break-within-label-switch.expect.md

@@ -40,14 +40,14 @@ function useHook(cond) {
     log = [];
     bb0: switch (CONST_STRING0) {
       case CONST_STRING0: {
-        log.push(`@A`);
+        log.push("@A");
         if (cond) {
           break bb0;
         }
 
-        log.push(`@B`);
+        log.push("@B");
 
-        log.push(`@C`);
+        log.push("@C");
       }
     }
     $[0] = cond;