lowerOptionalCallExpression() — react Function Reference

Source Code

compiler/packages/babel-plugin-react-compiler/src/HIR/BuildHIR.ts lines 2787–2947

function lowerOptionalCallExpression(
  builder: HIRBuilder,
  expr: NodePath<t.OptionalCallExpression>,
  parentAlternate: BlockId | null,
): InstructionValue {
  const optional = expr.node.optional;
  const calleePath = expr.get('callee');
  const loc = expr.node.loc ?? GeneratedSource;
  const place = buildTemporaryPlace(builder, loc);
  const continuationBlock = builder.reserve(builder.currentBlockKind());
  const consequent = builder.reserve('value');

  /*
   * block to evaluate if the callee is null/undefined, this sets the result of the call to undefined.
   * note that we only create an alternate when first entering an optional subtree of the ast: if this
   * is a child of an optional node, we use the alterate created by the parent.
   */
  const alternate =
    parentAlternate !== null
      ? parentAlternate
      : builder.enter('value', () => {
          const temp = lowerValueToTemporary(builder, {
            kind: 'Primitive',
            value: undefined,
            loc,
          });
          lowerValueToTemporary(builder, {
            kind: 'StoreLocal',
            lvalue: {kind: InstructionKind.Const, place: {...place}},
            value: {...temp},
            type: null,
            loc,
          });
          return {
            kind: 'goto',
            variant: GotoVariant.Break,
            block: continuationBlock.id,
            id: makeInstructionId(0),
            loc,
          };
        });

  /*
   * Lower the callee within the test block to represent the fact that the code for the callee is
   * scoped within the optional
   */
  let callee:
    | {kind: 'CallExpression'; callee: Place}
    | {kind: 'MethodCall'; receiver: Place; property: Place};
  const testBlock = builder.enter('value', () => {
    if (calleePath.isOptionalCallExpression()) {
      // Recursively call lowerOptionalCallExpression to thread down the alternate block
      const value = lowerOptionalCallExpression(builder, calleePath, alternate);
      const valuePlace = lowerValueToTemporary(builder, value);
      callee = {
        kind: 'CallExpression',
        callee: valuePlace,
      };
    } else if (calleePath.isOptionalMemberExpression()) {
      const {object, value} = lowerOptionalMemberExpression(
        builder,
        calleePath,
        alternate,
      );
      callee = {
        kind: 'MethodCall',
        receiver: object,
        property: value,
      };
    } else if (calleePath.isMemberExpression()) {
      const memberExpr = lowerMemberExpression(builder, calleePath);
      const propertyPlace = lowerValueToTemporary(builder, memberExpr.value);
      callee = {
        kind: 'MethodCall',
        receiver: memberExpr.object,
        property: propertyPlace,
      };
    } else {
      callee = {
        kind: 'CallExpression',
        callee: lowerExpressionToTemporary(builder, calleePath),