Problem

oxc over-bails on generic functions (Component<T>, useThing<T>()) that babel-plugin-react-compiler compiles. It emits [ReactCompiler] Todo: Unsupported declaration type for hoisting with help variable "T" declared with Unknown, then passes the whole function through unmemoized. This was the largest oxc capability gap vs upstream Babel across the ecosystem corpus.

Example — actual/.../autocomplete/Autocomplete.tsx: oxc _c was [5, 6, 11], Babel [5, 6, 11, 26, 125]. oxc missed the two generic components SingleAutocomplete<T extends AutocompleteItem> and MultiAutocomplete<T extends AutocompleteItem>. After this change oxc emits [5, 6, 11, 26, 125] — identical to Babel.

Mechanism

The referenced-before-declared hoisting scan in build_hir.rs (lower_block_statement_inner) collects "hoistable" bindings of a block, then hoists any that are referenced inside a nested function before their declaration. A hoisted binding whose declaration kind is neither FunctionDeclaration nor VariableDeclarator records the Unsupported declaration type for hoisting error.

The scan mirrors Babel's BuildHIR case 'BlockStatement'. The key upstream line is:

for (const [, binding] of Object.entries(stmt.scope.bindings)) { ... }   // hoistable set
const binding = id.scope.getBinding(id.node.name);                       // per-reference lookup
if (binding != null && hoistableIdentifiers.has(binding.identifier) && (fnDepth > 0 || ...))

Babel never registers a type parameter (or interface, or pure type alias) in scope.bindings. Verified directly against the fork's Babel:

function C<T>(props){ const f = () => props.v as T; ... }
=> scope.bindings = ["props", "f"]        // no T
   getBinding("T") === undefined

So for Babel a type name has no binding, the hoist check short-circuits, and generic functions compile.

oxc's semantic model does give type parameters/interfaces a symbol. With binding_kind/decl_kind both Unknown, they passed the hoistable filter, and every pure-type-position reference to T inside a nested function ((y: T), x as T, useMemo<T>(), new Set<T>(), <Table<T>/>, const s: Array<T>, (): T =>) looked like a referenced-before-declared use — bailing the whole function.

Fix (narrow, binding-side)

Exclude type-only symbols from the hoistable set, matching Babel's scope.bindings exactly:

// scope.rs
pub fn is_type_only_binding(&self, symbol_id: SymbolId) -> bool {
    let flags = self.scoping().symbol_flags(symbol_id);
    flags.is_type() && !flags.is_value()
}

is_type() && !is_value() selects exactly type parameters, interfaces, pure type aliases, and type-only imports. Classes, enums, value modules, and interface/class merged declarations keep is_value() and remain hoistable — matching Babel, which does register those.

This is deliberately a binding-side filter, not a reference-side one. It never touches how value bindings' references are counted, so it cannot change any value binding's hoist decision — which is what makes it safe. (Prior reference-side attempts that skipped type-position references or erased type params regressed because they also affected value bindings referenced in type positions.)

Validation

Fixture snapshot corpus (tests/snapshots/, 1734 fixtures): green. Exactly one snapshot changed — error.todo-round2_identifier_diff — and the change removes the spurious variable "OuterProps" declared with Unknown diagnostic (OuterProps is the type parameter of withRemountOnChange<OuterProps extends {}>). The fixture still bails on its genuine Handle ClassExpression expressions Todo, so the bail decision and No changes. output are preserved; only the bogus type-param diagnostic — which Babel never emits — is gone.

Ecosystem (697 generic-declaration candidate files across 44 repos, oxc vs fork Babel):

• 122 files hit the type-param over-bail before this change; all 122 no longer do.
• 467 candidates now produce an _c multiset byte-identical to Babel.
• Files where oxc memoizes but Babel bails were checked against git-old oxc. The handful of newly-diverging files bail in Babel for reasons unrelated to type parameters (Handle tagged template with interpolations, Expected all references to a variable to be consistently local or context references). A minimal non-generic probe confirms oxc already compiled tagged-template interpolations that Babel bails on before this change (old _c(4) == new _c(4), Babel CompileError) — so these are pre-existing oxc/Babel capability differences merely unmasked by removing a coincidental double-bail, not new over-compiles from this change. In three of them oxc gained a function whose _c value exactly matches a Babel slot (moving oxc closer to Babel).

cargo fmt and cargo clippy -p oxc_react_compiler --all-targets -- -D warnings are clean.