ffi/cc: compile inline C source via code option, drop C REPL temp files

cc() (bun:ffi) previously required a file path (`source`); the C REPL
wrote its accumulated buffer to a temp file on every eval. Add a
`code` option carrying inline C source text: Rust Source::String compiles
it directly with tcc_compile_string, and the JS wrapper passes it through
without path normalization. The C REPL now compiles from memory (no
/tmp/poly-c-repl-*.c), which also removes the pid-based collision window
between concurrent sessions. Entry compilation (source: file path) is
unchanged.

Author: liooil

src/js/bun/ffi.ts

@@ -212,18 +212,28 @@ function cc(options) {
     throw new Error("Expected options to be an object");
   }
 
-  let path = options?.source;
-  if (!path) {
-    throw new Error("Expected source to be a string to a file path");
-  }
-  if ($isJSArray(path)) {
-    for (let i = 0; i < path.length; i++) {
-      path[i] = normalizePath(path[i]);
+  let displayName;
+  if (options.code !== undefined) {
+    // Inline C source text — compiled directly by TinyCC, no temp file.
+    if (typeof options.code !== "string") {
+      throw new Error("Expected code to be a string of C source code");
     }
+    displayName = "<cc>";
   } else {
-    path = normalizePath(path);
+    let path = options?.source;
+    if (!path) {
+      throw new Error("Expected source to be a string to a file path");
+    }
+    if ($isJSArray(path)) {
+      for (let i = 0; i < path.length; i++) {
+        path[i] = normalizePath(path[i]);
+      }
+    } else {
+      path = normalizePath(path);
+    }
+    options.source = path;
+    displayName = path;
   }
-  options.source = path;
 
   const result = ccFn(options);
   if (Error.isError(result)) throw result;
@@ -240,7 +250,9 @@ function cc(options) {
         //    "/usr/lib/sqlite3.so"
         // we want
         //    "sqlite3_get_version() - sqlit3.so"
-        path.includes("/") ? `${key} (${path.split("/").pop()})` : `${key} (${path})`,
+        displayName.includes("/")
+          ? `${key} (${displayName.split("/").pop()})`
+          : `${key} (${displayName})`,
       );
     } else {
       // consistentcy

src/runtime/cli/repl.rs

@@ -2067,7 +2067,6 @@ impl<'a> Repl<'a> {
                  g.__polyCStmts = g.__polyCStmts ?? \"\";\n\
                  g.__polyCDefs = g.__polyCDefs ?? \"\";\n\
                  g.__polyC = g.__polyC ?? {{}};\n\
-                 const __path = (await import(\"node:os\")).tmpdir() + \"/poly-c-repl-\" + process.pid + \".c\";\n\
                  const __pre = \"#include <stdio.h>\\n#include <stdlib.h>\\n#include <string.h>\\nint __poly_marker(void) {{ return 0; }}\\n\";\n\
                  const __tmap = {{ int: \"i32\", \"unsigned int\": \"u32\", unsigned: \"u32\", long: \"i64\", \"unsigned long\": \"u64\", \"long long\": \"i64\", \"unsigned long long\": \"u64\", short: \"i16\", \"unsigned short\": \"u16\", char: \"i8\", \"unsigned char\": \"u8\", \"signed char\": \"i8\", float: \"f32\", double: \"f64\", size_t: \"usize\", ssize_t: \"isize\", int32_t: \"i32\", uint32_t: \"u32\", int64_t: \"i64\", uint64_t: \"u64\", int16_t: \"i16\", uint16_t: \"u16\", int8_t: \"i8\", uint8_t: \"u8\", void: \"void\" }};\n\
                  const __ctoffi = (t) => {{ t = String(t).trim().replace(/\\s+/g, \" \"); if (t.includes(\"*\")) return \"ptr\"; return __tmap[t] ?? \"i32\"; }};\n\
@@ -2083,7 +2082,7 @@ impl<'a> Repl<'a> {
                    }}\n\
                    return sigs;\n\
                  }};\n\
-                 const __compile = async (src, syms) => {{ await Bun.write(__path, src); return cc({{ source: __path, symbols: Object.assign({{ __poly_marker: {{ args: [], returns: \"int\" }} }}, syms) }}); }};\n\
+                 const __compile = (src, syms) => cc({{ code: src, symbols: Object.assign({{ __poly_marker: {{ args: [], returns: \"int\" }} }}, syms) }});\n\
                  const __in = {json};\n\
                  const __isExpr = !(__in.trimEnd().endsWith(\";\") || __in.trimEnd().endsWith(\"}}\"));\n\
                  const __ln = \"__poly_line_\" + (g.__polyLineN = (g.__polyLineN ?? 0) + 1);\n\

src/runtime/ffi/ffi_body.rs

@@ -276,13 +276,16 @@ impl Default for CompileC {
 enum Source {
     File(ZBox),
     Files(Vec<ZBox>),
+    /// Inline C source text (the `code` option) — compiled without a file.
+    String(ZBox),
 }
 
 impl Source {
     pub(crate) fn first(&self) -> &ZStr {
         match self {
             Source::File(f) => f,
             Source::Files(files) => &files[0],
+            Source::String(code) => code,
         }
     }
 
@@ -308,6 +311,13 @@ impl Source {
                     *current_file_for_errors = ZBox::from_bytes(b"");
                 }
             }
+            Source::String(code) => {
+                *current_file_for_errors = ZBox::from_bytes(b"<cc>");
+                state
+                    .compile_string(code)
+                    .map_err(|_| crate::Error::CompilationError)?;
+                *current_file_for_errors = ZBox::from_bytes(b"");
+            }
         }
         Ok(())
     }
@@ -1169,6 +1179,22 @@ impl FFI {
             }
         }
 
+        // Inline C source text — compiled directly, no temp file. Takes
+        // precedence over `source` (the REPL compiles accumulated buffers).
+        if let Some(code_value) =
+            object.get_own(global_this, &bun_core::String::borrow_utf8(b"code"))?
+        {
+            if !code_value.is_string() {
+                return Err(global_this.throw_invalid_argument_type_value(
+                    b"code",
+                    b"string",
+                    code_value,
+                ));
+            }
+            let code = code_value.get_zig_string(global_this)?.to_owned_slice_z();
+            compile_c.source = Source::String(code);
+        }
+
         if global_this.has_exception() {
             return Err(JsError::Thrown);
         }