moon test --target native hangs: TCC cannot compile 7MB generated C file

[mizchi]

Problem

moon test --target native hangs indefinitely when testing packages that depend on moonbitlang/async (http, tls, socket).

Root Cause

The generated C file for the test binary is ~7MB (due to async + TLS + socket being linked together). The built-in TCC compiler (~/.moon/bin/internal/tcc) hangs when compiling this file — it shows 0% CPU usage and never completes.

Reproduction

# Any package that imports moonbitlang/async/http
moon test --target native -p client
# Hangs at TCC compilation step

The TCC process can be observed:

ps aux | grep tcc
# Shows: tcc @...client.whitebox_test.rspfile — 0% CPU, runs indefinitely

Verification

The same C file compiles in 0.97 seconds with clang:

time clang -O0 -g -I~/.moon/include -L~/.moon/lib \
  -DMOONBIT_NATIVE_NO_SYS_HEADER -DMOONBIT_USE_SHARED_RUNTIME -fPIC \
  ...dylibs... \
  _build/native/debug/test/client/client.whitebox_test.c \
  -o /tmp/test
# 0.74s user, 0.97s total

Environment

• moon 0.1.20260330 (c527f57 2026-03-30)
• macOS Darwin 25.2.0 (arm64)
• Generated C file: 7.0MB

Workaround

None for local moon test --target native. The moon check command works fine for type checking. Only the test execution (which requires TCC compilation) is affected.

Suggestion

Consider supporting an external C compiler via environment variable (e.g., MOONC_CC=clang) for native target compilation, especially for large generated C files.

[mizchi]

Confirmed: this is on the latest stable release (moon 0.1.20260330). There is no newer version available via moon upgrade — the latest published binary is the same build. So this is not a bleeding-edge regression.

[mizchi]

Minimal reproduction found

The issue is not TLS-specific. It's a TCC file size limit around 5MB.

Repro (single file, no external packages needed beyond async)

moon.mod.json:

{"name":"test/repro","version":"0.1.0","source":"src","deps":{"moonbitlang/async":"0.17.0"},"preferred-target":"native"}

src/minimal/moon.pkg:

import { "moonbitlang/async", "moonbitlang/async/socket", "moonbitlang/async/http", }

src/minimal/test.mbt:

///|
#cfg(target="native")
async test "http server + client" {
  let server = @http.Server(@socket.Addr::new(0x7F000001, 0))
  let port = server.addr().port()
  @async.with_task_group(async fn(group) {
    group.spawn_bg(async fn() {
      server.run_forever(async fn(_req, _reader, conn) {
        conn.send_response(200, "OK")
        conn.write("{\"ok\":true}")
        conn.end_response()
      }, allow_failure=true)
    })
    let client = @http.Client("http://127.0.0.1:\{port}")
    defer client.close()
    let response = client.get("/test")
    assert_eq!(response.code, 200)
    server.close()
  })
}

moon test --target native -p minimal
# Hangs — TCC at 0% CPU on 5.6MB generated C file

Bisection results

Generated C size	TCC result
1.5MB (async + http import only)	OK
4.7MB (@http.Client("url") in test)	OK
5.6MB (Server + Client in same test)	Hangs
7.0MB (full package with 3 tests)	Hangs

The threshold is approximately 5MB. clang compiles all of these in <1 second.

[Guest0x0]

Seems like a tcc/moonc issue then. Will investigate from that side.