validateExhaustiveDependencies() — react Function Reference

Source Code

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateExhaustiveDependencies.ts lines 89–219

export function validateExhaustiveDependencies(
  fn: HIRFunction,
): Result<void, CompilerError> {
  const env = fn.env;
  const reactive = collectReactiveIdentifiersHIR(fn);

  const temporaries: Map<IdentifierId, Temporary> = new Map();
  for (const param of fn.params) {
    const place = param.kind === 'Identifier' ? param : param.place;
    temporaries.set(place.identifier.id, {
      kind: 'Local',
      identifier: place.identifier,
      path: [],
      context: false,
      loc: place.loc,
    });
  }
  const error = new CompilerError();
  let startMemo: StartMemoize | null = null;

  function onStartMemoize(
    value: StartMemoize,
    dependencies: Set<InferredDependency>,
    locals: Set<IdentifierId>,
  ): void {
    CompilerError.invariant(startMemo == null, {
      reason: 'Unexpected nested memo calls',
      loc: value.loc,
    });
    startMemo = value;
    dependencies.clear();
    locals.clear();
  }
  function onFinishMemoize(
    value: FinishMemoize,
    dependencies: Set<InferredDependency>,
    locals: Set<IdentifierId>,
  ): void {
    CompilerError.invariant(
      startMemo != null && startMemo.manualMemoId === value.manualMemoId,
      {
        reason: 'Found FinishMemoize without corresponding StartMemoize',
        loc: value.loc,
      },
    );
    if (env.config.validateExhaustiveMemoizationDependencies) {
      visitCandidateDependency(value.decl, temporaries, dependencies, locals);
      const inferred: Array<InferredDependency> = Array.from(dependencies);

      const diagnostic = validateDependencies(
        inferred,
        startMemo.deps ?? [],
        reactive,
        startMemo.depsLoc,
        ErrorCategory.MemoDependencies,
        'all',
      );
      if (diagnostic != null) {
        error.pushDiagnostic(diagnostic);
      }
    }

    dependencies.clear();
    locals.clear();
    startMemo = null;
  }

  collectDependencies(
    fn,
    temporaries,
    {
      onStartMemoize,
      onFinishMemoize,
      onEffect: (inferred, manual, manualMemoLoc) => {
        if (env.config.validateExhaustiveEffectDependencies === 'off') {
          return;
        }
        if (DEBUG) {
          console.log(Array.from(inferred, printInferredDependency));
          console.log(Array.from(manual, printInferredDependency));
        }