feat(runtime): expose gc() as a callable globalThis property (#5712)

Follow-up to the `typeof gc` capability-guard fix. That change makes the
bare-identifier guard `if (typeof gc === "function") gc()` work, but the
other idiomatic capability-guard forms read `gc` as a VALUE:

  if (globalThis.gc) globalThis.gc();   // Node CLI docs' own example
  global.gc?.();                        // Bun's documented form
  const g = globalThis.gc; g?.();

These all read `globalThis.gc`, which Perry never installed, so they were
`undefined` / no-ops even though `gc()` is callable.

Install `gc` as a real callable property on the globalThis singleton (a
ClosureHeader-backed value, like `setTimeout`/`queueMicrotask`), routed to
the same `js_gc_collect` the bare `gc()` intrinsic uses. Non-enumerable; the
optional Node `force` argument is accepted but ignored (Perry's gc is a full
collection). Now `typeof globalThis.gc === "function"`, `globalThis.gc` is
truthy, and `globalThis.gc()` / `globalThis.gc?.()` / `gc?.()` all run a real
collection.

Author: machineloop

crates/perry-runtime/src/object/global_this.rs

@@ -61,7 +61,7 @@ pub(crate) use builtin_thunks::{
     global_this_btoa_thunk, global_this_decode_uri_component_thunk, global_this_decode_uri_thunk,
     global_this_encode_uri_component_thunk, global_this_encode_uri_thunk,
     global_this_error_capture_stack_trace_thunk, global_this_error_is_error_thunk,
-    global_this_error_prepare_stack_trace_thunk, global_this_escape_thunk,
+    global_this_error_prepare_stack_trace_thunk, global_this_escape_thunk, global_this_gc_thunk,
     global_this_is_finite_thunk, global_this_is_nan_thunk, global_this_number_thunk,
     global_this_object_thunk, global_this_parse_float_thunk, global_this_parse_int_thunk,
     global_this_string_thunk, global_this_structured_clone_thunk, global_this_unescape_thunk,

crates/perry-runtime/src/object/global_this/builtin_thunks.rs

@@ -276,6 +276,20 @@ pub(crate) extern "C" fn global_this_is_nan_thunk(
     crate::builtins::js_is_nan(value)
 }
 
+/// `globalThis.gc([force])` — request a garbage collection. This is the value
+/// form of the same builtin the bare `gc()` call-intrinsic routes to, so
+/// `globalThis.gc()`, `global.gc?.()`, `if (globalThis.gc) gc()`, and
+/// `const f = gc; f()` all run a real collection. Perry's collector treats
+/// `gc()` as a full collection, so Node's optional `force` argument is accepted
+/// but ignored. Returns `undefined`.
+pub(crate) extern "C" fn global_this_gc_thunk(
+    _closure: *const crate::closure::ClosureHeader,
+    _force: f64,
+) -> f64 {
+    crate::gc::js_gc_collect();
+    f64::from_bits(crate::value::JSValue::undefined().bits())
+}
+
 pub(crate) extern "C" fn global_this_is_finite_thunk(
     _closure: *const crate::closure::ClosureHeader,
     value: f64,

crates/perry-runtime/src/object/global_this/populate.rs

@@ -425,6 +425,10 @@ pub(crate) fn populate_global_this_builtins(singleton: *mut ObjectHeader) {
                 false,
                 true,
             ),
+            // `gc([force])` — value form of the bare `gc()` call-intrinsic.
+            // Non-enumerable (a debug/diagnostic global). The optional `force`
+            // arg is accepted (arity 1) but ignored — Perry's gc is full.
+            "gc" => (global_this_gc_thunk as *const u8, 1, false, false),
             // #2905: standard global helper functions.
             "parseInt" => (global_this_parse_int_thunk as *const u8, 2, false, false),
             "parseFloat" => (global_this_parse_float_thunk as *const u8, 1, false, false),

crates/perry-runtime/src/object/global_this_tables.rs

@@ -196,6 +196,11 @@ pub(crate) const GLOBAL_THIS_BUILTIN_FUNCTIONS: &[&str] = &[
     "setImmediate",
     "clearImmediate",
     "queueMicrotask",
+    // The `gc()` builtin, exposed as a real callable global value so the
+    // capability-guard idioms `if (globalThis.gc) gc()` / `global.gc?.()` /
+    // `const f = gc; f()` work (Perry's `gc()` is always available, unlike
+    // Node's `--expose-gc`-gated one).
+    "gc",
     // #2905: standard global helper functions. These route through Perry's
     // real direct-call runtime helpers, so `const p = parseInt; p("42px")`
     // and `globalThis.encodeURIComponent("a b")` match Node.