lowerStatement() — react Function Reference

Source Code

compiler/packages/babel-plugin-react-compiler/src/HIR/BuildHIR.ts lines 267–1489

function lowerStatement(
  builder: HIRBuilder,
  stmtPath: NodePath<t.Statement>,
  label: string | null = null,
): void {
  const stmtNode = stmtPath.node;
  switch (stmtNode.type) {
    case 'ThrowStatement': {
      const stmt = stmtPath as NodePath<t.ThrowStatement>;
      const value = lowerExpressionToTemporary(builder, stmt.get('argument'));
      const handler = builder.resolveThrowHandler();
      if (handler != null) {
        /*
         * NOTE: we could support this, but a `throw` inside try/catch is using exceptions
         * for control-flow and is generally considered an anti-pattern. we can likely
         * just not support this pattern, unless it really becomes necessary for some reason.
         */
        builder.errors.push({
          reason:
            '(BuildHIR::lowerStatement) Support ThrowStatement inside of try/catch',
          category: ErrorCategory.Todo,
          loc: stmt.node.loc ?? null,
          suggestions: null,
        });
      }
      const terminal: ThrowTerminal = {
        kind: 'throw',
        value,
        id: makeInstructionId(0),
        loc: stmt.node.loc ?? GeneratedSource,
      };
      builder.terminate(terminal, 'block');
      return;
    }
    case 'ReturnStatement': {
      const stmt = stmtPath as NodePath<t.ReturnStatement>;
      const argument = stmt.get('argument');
      let value;
      if (argument.node === null) {
        value = lowerValueToTemporary(builder, {
          kind: 'Primitive',
          value: undefined,
          loc: GeneratedSource,
        });
      } else {
        value = lowerExpressionToTemporary(
          builder,
          argument as NodePath<t.Expression>,
        );
      }
      const terminal: ReturnTerminal = {
        kind: 'return',
        returnVariant: 'Explicit',
        loc: stmt.node.loc ?? GeneratedSource,
        value,
        id: makeInstructionId(0),
        effects: null,
      };
      builder.terminate(terminal, 'block');
      return;
    }
    case 'IfStatement': {
      const stmt = stmtPath as NodePath<t.IfStatement>;
      //  Block for code following the if
      const continuationBlock = builder.reserve('block');
      //  Block for the consequent (if the test is truthy)
      const consequentBlock = builder.enter('block', _blockId => {
        const consequent = stmt.get('consequent');
        lowerStatement(builder, consequent);
        return {
          kind: 'goto',
          block: continuationBlock.id,
          variant: GotoVariant.Break,
          id: makeInstructionId(0),
          loc: consequent.node.loc ?? GeneratedSource,
        };
      });
      //  Block for the alternate (if the test is not truthy)
      let alternateBlock: BlockId;
      const alternate = stmt.get('alternate');
      if (hasNode(alternate)) {