validateDependencies() — react Function Reference

Source Code

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateExhaustiveDependencies.ts lines 221–495

function validateDependencies(
  inferred: Array<InferredDependency>,
  manualDependencies: Array<ManualMemoDependency>,
  reactive: Set<IdentifierId>,
  manualMemoLoc: SourceLocation | null,
  category:
    | ErrorCategory.MemoDependencies
    | ErrorCategory.EffectExhaustiveDependencies,
  exhaustiveDepsReportMode: 'all' | 'missing-only' | 'extra-only',
): CompilerDiagnostic | null {
  // Sort dependencies by name and path, with shorter/non-optional paths first
  inferred.sort((a, b) => {
    if (a.kind === 'Global' && b.kind == 'Global') {
      return a.binding.name.localeCompare(b.binding.name);
    } else if (a.kind == 'Local' && b.kind == 'Local') {
      CompilerError.invariant(
        a.identifier.name != null &&
          a.identifier.name.kind === 'named' &&
          b.identifier.name != null &&
          b.identifier.name.kind === 'named',
        {
          reason: 'Expected dependencies to be named variables',
          loc: a.loc,
        },
      );
      if (a.identifier.id !== b.identifier.id) {
        return a.identifier.name.value.localeCompare(b.identifier.name.value);
      }
      if (a.path.length !== b.path.length) {
        // if a's path is shorter this returns a negative, sorting a first
        return a.path.length - b.path.length;
      }
      for (let i = 0; i < a.path.length; i++) {
        const aProperty = a.path[i];
        const bProperty = b.path[i];
        const aOptional = aProperty.optional ? 0 : 1;
        const bOptional = bProperty.optional ? 0 : 1;
        if (aOptional !== bOptional) {
          // sort non-optionals first
          return aOptional - bOptional;
        } else if (aProperty.property !== bProperty.property) {
          return String(aProperty.property).localeCompare(
            String(bProperty.property),
          );
        }
      }
      return 0;
    } else {
      const aName =
        a.kind === 'Global' ? a.binding.name : a.identifier.name?.value;
      const bName =
        b.kind === 'Global' ? b.binding.name : b.identifier.name?.value;
      if (aName != null && bName != null) {
        return aName.localeCompare(bName);
      }
      return 0;
    }
  });
  // remove redundant inferred dependencies
  retainWhere(inferred, (dep, ix) => {
    const match = inferred.findIndex(prevDep => {
      return (
        isEqualTemporary(prevDep, dep) ||
        (prevDep.kind === 'Local' &&
          dep.kind === 'Local' &&
          prevDep.identifier.id === dep.identifier.id &&
          isSubPath(prevDep.path, dep.path))
      );
    });
    // only retain entries that don't have a prior match
    return match === -1 || match >= ix;
  });
  // Validate that all manual dependencies belong there
  if (DEBUG) {
    console.log('manual');
    console.log(
      manualDependencies
        .map(x => '  ' + printManualMemoDependency(x))
        .join('\n'),
    );
    console.log('inferred');