nameAnonymousFunctionsImpl() — react Function Reference

Source Code

compiler/packages/babel-plugin-react-compiler/src/Transform/NameAnonymousFunctions.ts lines 52–179

function nameAnonymousFunctionsImpl(fn: HIRFunction): Array<Node> {
  // Functions that we track to generate names for
  const functions: Map<IdentifierId, Node> = new Map();
  // Tracks temporaries that read from variables/globals/properties
  const names: Map<IdentifierId, string> = new Map();
  // Tracks all function nodes to bubble up for later renaming
  const nodes: Array<Node> = [];
  for (const block of fn.body.blocks.values()) {
    for (const instr of block.instructions) {
      const {lvalue, value} = instr;
      switch (value.kind) {
        case 'LoadGlobal': {
          names.set(lvalue.identifier.id, value.binding.name);
          break;
        }
        case 'LoadContext':
        case 'LoadLocal': {
          const name = value.place.identifier.name;
          if (name != null && name.kind === 'named') {
            names.set(lvalue.identifier.id, name.value);
          }
          const func = functions.get(value.place.identifier.id);
          if (func != null) {
            functions.set(lvalue.identifier.id, func);
          }
          break;
        }
        case 'PropertyLoad': {
          const objectName = names.get(value.object.identifier.id);
          if (objectName != null) {
            names.set(
              lvalue.identifier.id,
              `${objectName}.${String(value.property)}`,
            );
          }
          break;
        }
        case 'FunctionExpression': {
          const inner = nameAnonymousFunctionsImpl(value.loweredFunc.func);
          const node: Node = {
            fn: value,
            generatedName: null,
            inner,
          };
          /**
           * Bubble-up all functions, even if they're named, so that we can
           * later generate names for any inner anonymous functions
           */
          nodes.push(node);
          if (value.name == null) {
            // but only generate names for anonymous functions
            functions.set(lvalue.identifier.id, node);
          }
          break;
        }
        case 'StoreContext':
        case 'StoreLocal': {
          const node = functions.get(value.value.identifier.id);
          const variableName = value.lvalue.place.identifier.name;
          if (
            node != null &&
            node.generatedName == null &&
            variableName != null &&
            variableName.kind === 'named'
          ) {
            node.generatedName = variableName.value;
            functions.delete(value.value.identifier.id);
          }
          break;
        }
        case 'CallExpression':
        case 'MethodCall': {
          const callee =
            value.kind === 'MethodCall' ? value.property : value.callee;
          const hookKind = getHookKind(fn.env, callee.identifier);
          let calleeName: string | null = null;
          if (hookKind != null && hookKind !== 'Custom') {
            calleeName = hookKind;
          } else {
            calleeName = names.get(callee.identifier.id) ?? '(anonymous)';
          }