CollectDependenciesVisitor Class — react Architecture

Source Code

compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/PruneNonEscapingScopes.ts lines 397–1008

class CollectDependenciesVisitor extends ReactiveFunctionVisitor<
  Array<ReactiveScope>
> {
  env: Environment;
  state: State;
  options: MemoizationOptions;

  constructor(env: Environment, state: State) {
    super();
    this.env = env;
    this.state = state;
    this.options = {
      memoizeJsxElements: !this.env.config.enableForest,
      forceMemoizePrimitives:
        this.env.config.enableForest ||
        this.env.config.enablePreserveExistingMemoizationGuarantees,
    };
  }

  /*
   * Given a value, returns a description of how it should be memoized:
   * - lvalues: optional extra places that are lvalue-like in the sense of
   *   aliasing the rvalues
   * - rvalues: places that are aliased by the instruction's lvalues.
   * - level: the level of memoization to apply to this value
   */
  computeMemoizationInputs(
    value: ReactiveValue,
    lvalue: Place | null,
  ): {
    // can optionally return a custom set of lvalues per instruction
    lvalues: Array<LValueMemoization>;
    rvalues: Array<Place>;
  } {
    const env = this.env;
    const options = this.options;

    switch (value.kind) {
      case 'ConditionalExpression': {
        return {
          // Only need to memoize if the rvalues are memoized
          lvalues:
            lvalue !== null
              ? [{place: lvalue, level: MemoizationLevel.Conditional}]
              : [],
          rvalues: [
            // Conditionals do not alias their test value.
            ...this.computeMemoizationInputs(value.consequent, null).rvalues,
            ...this.computeMemoizationInputs(value.alternate, null).rvalues,
          ],
        };
      }
      case 'LogicalExpression': {
        return {
          // Only need to memoize if the rvalues are memoized
          lvalues:
            lvalue !== null
              ? [{place: lvalue, level: MemoizationLevel.Conditional}]
              : [],
          rvalues: [
            ...this.computeMemoizationInputs(value.left, null).rvalues,
            ...this.computeMemoizationInputs(value.right, null).rvalues,
          ],
        };
      }
      case 'SequenceExpression': {
        for (const instr of value.instructions) {
          this.visitValueForMemoization(instr.id, instr.value, instr.lvalue);
        }
        return {
          // Only need to memoize if the rvalues are memoized
          lvalues:
            lvalue !== null
              ? [{place: lvalue, level: MemoizationLevel.Conditional}]
              : [],
          /*
           * Only the final value of the sequence is a true rvalue:
           * values from the sequence's instructions are evaluated
           * as separate nodes
           */
          rvalues: this.computeMemoizationInputs(value.value, null).rvalues,