PropagateEarlyReturns.ts — react Source File

Source Code

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

import {visitReactiveFunction} from '.';
import {Effect} from '..';
import {
  Environment,
  GeneratedSource,
  InstructionKind,
  ReactiveFunction,
  ReactiveScope,
  ReactiveScopeBlock,
  ReactiveStatement,
  ReactiveTerminalStatement,
  makeInstructionId,
  makePropertyLiteral,
  promoteTemporary,
} from '../HIR';
import {createTemporaryPlace} from '../HIR/HIRBuilder';
import {EARLY_RETURN_SENTINEL} from './CodegenReactiveFunction';
import {ReactiveFunctionTransform, Transformed} from './visitors';

/**
 * This pass ensures that reactive blocks honor the control flow behavior of the
 * original code including early return semantics. Specifically, if a reactive
 * scope early returned during the previous execution and the inputs to that block
 * have not changed, then the code should early return (with the same value) again.
 *
 * Example:
 *
 * ```javascript
 * let x = [];
 * if (props.cond) {
 *   x.push(12);
 *   return x;
 * } else {
 *   return foo();
 * }
 * ```
 *
 * Imagine that this code is called twice in a row with props.cond = true. Both
 * times it should return the same object (===), an array `[12]`.
 *
 * The compilation strategy is as follows. For each top-level reactive scope
 * that contains (transitively) an early return:
 *
 * - Label the scope
 * - Synthesize a new temporary, eg `t0`, and set it as a declaration of the scope.
 *   This will represent the possibly-unset return value for that scope.
 * - Make the first instruction of the scope the declaration of that temporary,
 *   assigning a sentinel value (can reuse the same symbol as we use for cache slots).
 *   This assignment ensures that if we don't take an early return, that the value
 *   is the sentinel.
 * - Replace all `return` statements with:
 *   - An assignment of the temporary with the value being returned.
 *   - A `break` to the reactive scope's label.
// ... (278 more lines)