visitValueBlock() — react Function Reference

Source Code

compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/BuildReactiveFunction.ts lines 894–987

  visitValueBlock(
    blockId: BlockId,
    loc: SourceLocation,
    fallthrough: BlockId | null = null,
  ): {block: BlockId; value: ReactiveValue; place: Place; id: InstructionId} {
    const block = this.cx.ir.blocks.get(blockId)!;
    // If we've reached the fallthrough block, stop recursing
    if (fallthrough !== null && blockId === fallthrough) {
      CompilerError.invariant(false, {
        reason: 'Did not expect to reach the fallthrough of a value block',
        description: `Reached bb${blockId}, which is the fallthrough for this value block`,
        loc,
      });
    }
    if (block.terminal.kind === 'branch') {
      if (block.instructions.length === 0) {
        return {
          block: block.id,
          place: block.terminal.test,
          value: {
            kind: 'LoadLocal',
            place: block.terminal.test,
            loc: block.terminal.test.loc,
          },
          id: block.terminal.id,
        };
      }
      return this.extractValueBlockResult(block.instructions, block.id, loc);
    } else if (block.terminal.kind === 'goto') {
      if (block.instructions.length === 0) {
        CompilerError.invariant(false, {
          reason: 'Unexpected empty block with `goto` terminal',
          description: `Block bb${block.id} is empty`,
          loc,
        });
      }
      return this.extractValueBlockResult(block.instructions, block.id, loc);
    } else if (block.terminal.kind === 'maybe-throw') {
      /*
       * ReactiveFunction does not explicitly model maybe-throw semantics,
       * so maybe-throw terminals in value blocks flatten away. In general
       * we recurse to the continuation block.
       *
       * However, if the last portion
       * of the value block is a potentially throwing expression, then the
       * value block could be of the form
       * ```
       * bb1:
       *   ...StoreLocal for the value block...
       *   maybe-throw continuation=bb2
       * bb2:
       *   goto (exit the value block)
       * ```
       *
       * Ie what would have been a StoreLocal+goto is split up because of
       * the maybe-throw. We detect this case and return the value of the
       * current block as the result of the value block
       */
      const continuationId = block.terminal.continuation;
      const continuationBlock = this.cx.ir.blocks.get(continuationId)!;
      if (
        continuationBlock.instructions.length === 0 &&
        continuationBlock.terminal.kind === 'goto'
      ) {
        return this.extractValueBlockResult(
          block.instructions,
          continuationBlock.id,
          loc,
        );
      }

      const continuation = this.visitValueBlock(
        continuationId,
        loc,
        fallthrough,
      );
      return this.wrapWithSequence(block.instructions, continuation, loc);
    } else {
      /*
       * The value block ended in a value terminal, recurse to get the value
       * of that terminal and stitch them together in a sequence.