Compiler: NonReactive annotation

[srubin]

Summary

Automatic stable-identity codegen for handler-style functions in components, gated behind new feature flags. The goal is to reduce the amount of manual memoization (useCallback, custom annotations) users have to write for the common case of "inline function that's only passed as a JSX prop."

There are two layers:

1. NonReactive<T> annotation + two-slot codegen (already in earlier commits on this branch)

Users can type a local handler as NonReactive<T> (or wrap it with nonReactive(...)). The compiler then emits a two-slot cache for that function:

t1 = () => doThing(value);           // latest closure, updated every render
$[0] = t1;
if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
  t1 = (...args) => $[0](...args);   // stable wrapper, created once
  $[1] = t1;
}

The wrapper has stable identity for downstream consumers but always delegates to the current closure, so captured values stay fresh.

This powers: excluding the handler from reactive deps (InferReactivePlaces, ValidateExhaustiveDependencies, InferEffectDependencies), and enabling ref-access through it.

2. Usage-based inference (new in this PR's latest commit)

Gated behind enableInferNonReactiveHandlers. A new pass inferNonReactiveHandlers runs after inferTypes and, for each FunctionExpression in the component, checks whether every transitive use flows only into safe sinks:

• Safe: JSX attribute, useEffect / useLayoutEffect / useInsertionEffect / useEffectEvent argument, aliasing transfers (LoadLocal / StoreLocal / phi).
• Bails out on: direct call, argument to a non-effect hook (useMemo, useCallback, useState, custom hooks), stored in an object or array (escape), returned from the component, flowed through a context variable, or an explicit Reactive<T> opt-out annotation.

If every use is safe, the function's identifier types are mutated to BuiltInNonReactive and the existing markNonReactiveScopes pass drives the two-slot codegen unchanged. Also handles inline arrows in JSX (no intermediate const required) via a small extension to MarkNonReactiveScopes.

Escape hatches

• Reactive<T> annotation on a local to opt out of the inference (preferred — more grokkable at the call site)
• Explicit useCallback still works
• Local NonReactive<T> annotation and nonReactive() wrapper remain as forceful opt-ins for cases the inference bails out on

The prop-level NonReactive<T> annotation (previously on component parameters) was removed in this PR — the use cases (cross-module stability guarantees, suppressing Child's exhaustive-deps warnings, ref access through a passed-in prop) were deemed not worth the complexity right now.

Feature flags

• enableNonReactiveAnnotation — existing gate for the annotation + two-slot codegen.
• enableUseTypeAnnotations — prerequisite for reading NonReactive<T> / Reactive<T> off variable declarations.
• enableInferNonReactiveHandlers — new flag for the usage-based inference. Requires enableNonReactiveAnnotation.

All default to false — no behavior change for existing users.

How did you test this change?

• Full snapshot suite passes: 1850 / 1850 (yarn snap).
• yarn tsc --noEmit clean.
• New fixtures under compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/non-reactive/:
  • infer-non-reactive-inline-handler — baseline: const h = () => …; <button onClick={h}/> → two-slot codegen
  • infer-non-reactive-inline-jsx — inline arrow directly in JSX attribute → two-slot
  • infer-non-reactive-aliased — handler relayed through a second local
  • infer-non-reactive-reactive-optout — Reactive<T> keeps the value-cached codegen
  • infer-non-reactive-bailout-local-call — calling the handler in render bails out
  • infer-non-reactive-bailout-usememo — passing to useMemo bails out
  • infer-non-reactive-bailout-object-escape — storing in an object bails out
  • non-reactive-prop-propagation — cross-component: Parent's handler gets stabilized, Child caches its JSX on a stable identity so it never invalidates