validateSourceLocations() — react Function Reference

Source Code

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateSourceLocations.ts lines 121–313

export function validateSourceLocations(
  func: NodePath<
    t.FunctionDeclaration | t.ArrowFunctionExpression | t.FunctionExpression
  >,
  generatedAst: CodegenFunction,
): Result<void, CompilerError> {
  const errors = new CompilerError();

  /*
   * Step 1: Collect important locations from the original source
   * Note: Multiple node types can share the same location (e.g. VariableDeclarator and Identifier)
   */
  const importantOriginalLocations = new Map<
    string,
    {loc: t.SourceLocation; nodeTypes: Set<string>}
  >();

  func.traverse({
    enter(path) {
      const node = path.node;

      // Only track node types that Istanbul instruments
      if (!IMPORTANT_INSTRUMENTED_TYPES.has(node.type)) {
        return;
      }

      // Skip manual memoization that the compiler intentionally removes
      if (isManualMemoization(node)) {
        return;
      }

      /*
       * Skip return statements inside arrow functions that will be simplified to expression body.
       * The compiler transforms `() => { return expr }` to `() => expr` in CodegenReactiveFunction
       */
      if (t.isReturnStatement(node) && node.argument != null) {
        const parentBody = path.parentPath;
        const parentFunc = parentBody?.parentPath;
        if (
          parentBody?.isBlockStatement() &&
          parentFunc?.isArrowFunctionExpression() &&
          parentBody.node.body.length === 1 &&
          parentBody.node.directives.length === 0
        ) {
          return;
        }
      }

      // Collect the location if it exists
      if (node.loc) {
        const key = locationKey(node.loc);
        const existing = importantOriginalLocations.get(key);
        if (existing) {
          existing.nodeTypes.add(node.type);
        } else {
          importantOriginalLocations.set(key, {
            loc: node.loc,
            nodeTypes: new Set([node.type]),
          });
        }
      }
    },
  });

  // Step 2: Collect all locations from the generated AST with their node types
  const generatedLocations = new Map<string, Set<string>>();

  function collectGeneratedLocations(node: t.Node): void {
    if (node.loc) {
      const key = locationKey(node.loc);
      const nodeTypes = generatedLocations.get(key);
      if (nodeTypes) {
        nodeTypes.add(node.type);
      } else {
        generatedLocations.set(key, new Set([node.type]));
      }
    }

    // Use Babel's VISITOR_KEYS to traverse only actual node properties
    const keys = t.VISITOR_KEYS[node.type as keyof typeof t.VISITOR_KEYS];