Function probeComponentSource

package/src/utils/source-location.ts:573–630

* Probe a single fiber's component function by invoking it with a * throwing hooks dispatcher and parsing the resulting error stack.

(fiber: ReactFiber)

 * throwing hooks dispatcher and parsing the resulting error stack.
 */
function probeComponentSource(fiber: ReactFiber): SourceLocation | null {
  const fn = unwrapComponentType(fiber);
  if (!fn) return null;

  // Check cache
  if (sourceProbeCache.has(fn)) {
    return sourceProbeCache.get(fn)!;
  }

  const dispatcher = getReactDispatcher();
  if (!dispatcher) {
    sourceProbeCache.set(fn, null);
    return null;
  }

  const original = dispatcher.get();
  let result: SourceLocation | null = null;

  try {
    // Install a proxy dispatcher that throws an Error (with stack) on any hook access.
    // When the component calls useState/useEffect/etc., the proxy's get trap fires,
    // creating an Error whose stack trace includes the component's source location.
    const stackCapturingDispatcher = new Proxy(
      {},
      {
        get() {
          throw new Error("probe");
        },
      }
    );
    dispatcher.set(stackCapturingDispatcher);

    try {
      // Invoke the component — it will either:
      // 1. Call a hook → throws Error with stack (ideal case)
      // 2. Have no hooks → runs to completion (harmless, discarded), no stack to parse
      fn({});
    } catch (e) {
      if (e instanceof Error && e.message === "probe" && e.stack) {
        const frame = parseComponentFrame(e.stack);
        if (frame) {
          const cleaned = cleanSourcePath(frame.fileName);
          result = {
            fileName: cleaned,
            lineNumber: frame.line,
            columnNumber: frame.column,
            componentName: getComponentName(fiber) || undefined,
          };
        }
      }
    }
  } finally {
    dispatcher.set(original);
  }

  sourceProbeCache.set(fn, result);
  return result;
}