lowerAssignment() — react Function Reference

Source Code

compiler/packages/babel-plugin-react-compiler/src/HIR/BuildHIR.ts lines 3660–4220

function lowerAssignment(
  builder: HIRBuilder,
  loc: SourceLocation,
  kind: InstructionKind,
  lvaluePath: NodePath<t.LVal>,
  value: Place,
  assignmentKind: 'Destructure' | 'Assignment',
): InstructionValue {
  const lvalueNode = lvaluePath.node;
  switch (lvalueNode.type) {
    case 'Identifier': {
      const lvalue = lvaluePath as NodePath<t.Identifier>;
      const place = lowerIdentifierForAssignment(builder, loc, kind, lvalue);
      if (place === null) {
        return {
          kind: 'UnsupportedNode',
          loc: lvalue.node.loc ?? GeneratedSource,
          node: lvalue.node,
        };
      } else if (place.kind === 'Global') {
        const temporary = lowerValueToTemporary(builder, {
          kind: 'StoreGlobal',
          name: place.name,
          value,
          loc,
        });
        return {kind: 'LoadLocal', place: temporary, loc: temporary.loc};
      }
      const isHoistedIdentifier = builder.environment.isHoistedIdentifier(
        lvalue.node,
      );

      let temporary;
      if (builder.isContextIdentifier(lvalue)) {
        if (kind === InstructionKind.Const && !isHoistedIdentifier) {
          builder.errors.push({
            reason: `Expected \`const\` declaration not to be reassigned`,
            category: ErrorCategory.Syntax,
            loc: lvalue.node.loc ?? null,
            suggestions: null,
          });
        }

        if (
          kind !== InstructionKind.Const &&
          kind !== InstructionKind.Reassign &&
          kind !== InstructionKind.Let &&
          kind !== InstructionKind.Function
        ) {
          builder.errors.push({
            reason: `Unexpected context variable kind`,
            category: ErrorCategory.Syntax,
            loc: lvalue.node.loc ?? null,
            suggestions: null,
          });
          temporary = lowerValueToTemporary(builder, {
            kind: 'UnsupportedNode',
            node: lvalueNode,
            loc: lvalueNode.loc ?? GeneratedSource,
          });
        } else {
          temporary = lowerValueToTemporary(builder, {
            kind: 'StoreContext',
            lvalue: {place: {...place}, kind},
            value,
            loc,
          });
        }
      } else {
        const typeAnnotation = lvalue.get('typeAnnotation');
        let type: t.FlowType | t.TSType | null;
        if (typeAnnotation.isTSTypeAnnotation()) {
          const typePath = typeAnnotation.get('typeAnnotation');
          type = typePath.node;
        } else if (typeAnnotation.isTypeAnnotation()) {
          const typePath = typeAnnotation.get('typeAnnotation');
          type = typePath.node;
        } else {
          type = null;
        }
        temporary = lowerValueToTemporary(builder, {