recordInstructionDerivations() — react Function Reference

Source Code

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoDerivedComputationsInEffects_exp.ts lines 347–492

function recordInstructionDerivations(
  instr: Instruction,
  context: ValidationContext,
  isFirstPass: boolean,
): void {
  maybeRecordSetState(instr, context.setStateLoads, context.setStateUsages);

  let typeOfValue: TypeOfValue = 'ignored';
  let isSource: boolean = false;
  const sources: Set<IdentifierId> = new Set();
  const {lvalue, value} = instr;
  if (value.kind === 'FunctionExpression') {
    context.functions.set(lvalue.identifier.id, value);
    for (const [, block] of value.loweredFunc.func.body.blocks) {
      recordPhiDerivations(block, context);
      for (const instr of block.instructions) {
        recordInstructionDerivations(instr, context, isFirstPass);
      }
    }
  } else if (value.kind === 'CallExpression' || value.kind === 'MethodCall') {
    const callee =
      value.kind === 'CallExpression' ? value.callee : value.property;
    if (
      isUseEffectHookType(callee.identifier) &&
      value.args.length === 2 &&
      value.args[0].kind === 'Identifier' &&
      value.args[1].kind === 'Identifier'
    ) {
      const effectFunction = context.functions.get(value.args[0].identifier.id);
      const deps = context.candidateDependencies.get(
        value.args[1].identifier.id,
      );
      if (effectFunction != null && deps != null) {
        context.effectsCache.set(value.args[0].identifier.id, {
          effect: effectFunction.loweredFunc.func,
          dependencies: deps,
        });
      }
    } else if (isUseStateType(lvalue.identifier)) {
      typeOfValue = 'fromState';
      context.derivationCache.addDerivationEntry(
        lvalue,
        new Set(),
        typeOfValue,
        true,
      );
      return;
    }
  } else if (value.kind === 'ArrayExpression') {
    context.candidateDependencies.set(lvalue.identifier.id, value);
  }

  for (const operand of eachInstructionOperand(instr)) {
    if (context.setStateLoads.has(operand.identifier.id)) {
      const rootSetStateId = getRootSetState(
        operand.identifier.id,
        context.setStateLoads,
      );
      if (rootSetStateId !== null) {
        context.setStateUsages.get(rootSetStateId)?.add(operand.loc);
      }
    }

    const operandMetadata = context.derivationCache.cache.get(
      operand.identifier.id,
    );

    if (operandMetadata === undefined) {
      continue;
    }

    typeOfValue = joinValue(typeOfValue, operandMetadata.typeOfValue);
    sources.add(operand.identifier.id);
  }

  if (typeOfValue === 'ignored') {
    return;
  }

  for (const lvalue of eachInstructionLValue(instr)) {
    context.derivationCache.addDerivationEntry(