inlineImmediatelyInvokedFunctionExpressions() — react Function Reference

Source Code

compiler/packages/babel-plugin-react-compiler/src/Inference/InlineImmediatelyInvokedFunctionExpressions.ts lines 83–262

export function inlineImmediatelyInvokedFunctionExpressions(
  fn: HIRFunction,
): void {
  // Track all function expressions that are assigned to a temporary
  const functions = new Map<IdentifierId, FunctionExpression>();
  // Functions that are inlined
  const inlinedFunctions = new Set<IdentifierId>();

  /*
   * Iterate the *existing* blocks from the outer component to find IIFEs
   * and inline them. During iteration we will modify `fn` (by inlining the CFG
   * of IIFEs) so we explicitly copy references to just the original
   * function's blocks first. As blocks are split to make room for IIFE calls,
   * the split portions of the blocks will be added to this queue.
   */
  const queue = Array.from(fn.body.blocks.values());
  queue: for (const block of queue) {
    /*
     * We can't handle labels inside expressions yet, so we don't inline IIFEs if they are in an
     * expression block.
     */
    if (isStatementBlockKind(block.kind)) {
      for (let ii = 0; ii < block.instructions.length; ii++) {
        const instr = block.instructions[ii]!;
        switch (instr.value.kind) {
          case 'FunctionExpression': {
            if (instr.lvalue.identifier.name === null) {
              functions.set(instr.lvalue.identifier.id, instr.value);
            }
            break;
          }
          case 'CallExpression': {
            if (instr.value.args.length !== 0) {
              // We don't support inlining when there are arguments
              continue;
            }
            const body = functions.get(instr.value.callee.identifier.id);
            if (body === undefined) {
              // Not invoking a local function expression, can't inline
              continue;
            }

            if (
              body.loweredFunc.func.params.length > 0 ||
              body.loweredFunc.func.async ||
              body.loweredFunc.func.generator
            ) {
              // Can't inline functions with params, or async/generator functions
              continue;
            }

            // We know this function is used for an IIFE and can prune it later
            inlinedFunctions.add(instr.value.callee.identifier.id);

            // Create a new block which will contain code following the IIFE call
            const continuationBlockId = fn.env.nextBlockId;
            const continuationBlock: BasicBlock = {
              id: continuationBlockId,
              instructions: block.instructions.slice(ii + 1),
              kind: block.kind,
              phis: new Set(),
              preds: new Set(),
              terminal: block.terminal,
            };
            fn.body.blocks.set(continuationBlockId, continuationBlock);

            /*
             * Trim the original block to contain instructions up to (but not including)
             * the IIFE
             */
            block.instructions.length = ii;

            if (hasSingleExitReturnTerminal(body.loweredFunc.func)) {
              block.terminal = {
                kind: 'goto',
                block: body.loweredFunc.func.body.entry,
                id: block.terminal.id,
                loc: block.terminal.loc,
                variant: GotoVariant.Break,
              } as GotoTerminal;
              for (const block of body.loweredFunc.func.body.blocks.values()) {