fix: link valid stream insertion return values

.github/workflows/ci.yml

@@ -23,6 +23,9 @@ jobs:
       - name: Install dependencies
         run: npm ci
 
+      - name: Fetch Clang WASM artifacts
+        run: npm run fetch-clang
+
       - name: Verify manifest-driven version sync
         run: npm run version:check
 
@@ -38,5 +41,8 @@ jobs:
       - name: Run end-to-end session tests
         run: npm run test:e2e
 
+      - name: Run compiler linker end-to-end tests
+        run: npm run test:e2e:compiler
+
       - name: Run Firefox packaging smoke
         run: npm run test:browser:firefox

README.md

@@ -543,6 +543,10 @@ Copy the resulting `clang.js` and `clang.wasm` into `dist/clang/`.
   socket support.
 - **Standard library**: Only the subset of libc/libc++ compiled into the WASM
   sysroot is available.
+- **C++ exceptions**: `try`, `catch`, and `throw` are not supported. The bundled
+  WASI C++ runtime has no exception-unwinding support, so use return values,
+  error-state checks (such as `stream.fail()`), or other non-throwing error
+  handling instead.
 - **Execution time**: Long-running programs may trigger the browser's "unresponsive
   script" dialog.  The compiler runs in a dedicated Web Worker to avoid blocking
   the UI.

manifest.json

@@ -3,7 +3,7 @@
   "name": "browser.cpp",
   "short_name": "browser.cpp",
   "description": "In-browser C++20 IDE powered by Monaco Editor and WASM Clang",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "minimum_chrome_version": "105",
   "icons": {
     "16": "icons/icon16.png",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "browser.cpp",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "description": "In-browser C++20 IDE with WASM Clang toolchain",
   "private": true,
   "scripts": {
@@ -11,8 +11,9 @@
     "build": "npm run build:webpack && npm run build:targets",
     "build:firefox": "npm run build",
     "test:e2e": "node --experimental-detect-module --test scripts/e2e-session-persistence.test.mjs scripts/e2e-session-restore-choice.test.mjs scripts/e2e-multifile-build.test.mjs scripts/e2e-workspace-file-tracking.test.mjs scripts/e2e-terminal-mkdir.test.mjs scripts/e2e-terminal-stop.test.mjs scripts/e2e-terminal-git-removal.test.mjs scripts/e2e-terminal-stop-icon.test.mjs scripts/e2e-browser-compatibility.test.mjs scripts/e2e-firefox-compatibility.test.mjs scripts/e2e-firefox-jspi-stdin.test.mjs scripts/e2e-wasi-shim.test.mjs scripts/e2e-run-request.test.mjs scripts/e2e-release-packaging.test.mjs",
+    "test:e2e:compiler": "npm run test:preflight-clang && node --experimental-detect-module --test scripts/e2e-compiler-link.test.mjs",
     "test:preflight-clang": "node scripts/preflight-clang-artifacts.js",
-    "test:browser:chrome": "npm run test:preflight-clang && node scripts/smoke-browser.mjs chrome",
+    "test:browser:chrome": "npm run test:e2e:compiler && node scripts/smoke-browser.mjs chrome",
     "test:browser:edge": "npm run test:preflight-clang && node scripts/smoke-browser.mjs edge",
     "test:browser:brave": "npm run test:preflight-clang && node scripts/smoke-browser.mjs brave",
     "test:browser:chromium": "npm run test:preflight-clang && node scripts/smoke-browser.mjs chromium",

scripts/e2e-compiler-link.test.mjs

@@ -0,0 +1,159 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { parseCompilePlan } from '../src/workers/compile-plan.mjs';
+import { createWasiRuntime } from '../src/workers/wasi-shim.mjs';
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const clangDir = path.join(repoRoot, 'dist', 'clang');
+
+globalThis.self = globalThis;
+let toolsReady = null;
+
+function ensureTools() {
+  toolsReady ||= (async () => {
+    process.type = 'renderer';
+    await import(pathToFileURL(path.join(clangDir, 'clang.js')).href);
+    await import(pathToFileURL(path.join(clangDir, 'lld.js')).href);
+  })();
+  return toolsReady;
+}
+
+function callMain(module, args) {
+  try {
+    return module.callMain(args);
+  } catch (error) {
+    if (error?.name === 'ExitStatus') return error.status;
+    throw error;
+  }
+}
+
+function* tarContents(buffer) {
+  const data = new Uint8Array(buffer);
+  const decode = new TextDecoder();
+  let offset = 0;
+
+  while (offset + 512 <= data.length) {
+    const header = data.slice(offset, offset + 512);
+    const name = decode.decode(header.slice(0, 100)).replace(/\0.*$/, '');
+    if (!name) return;
+    const size = parseInt(decode.decode(header.slice(124, 136)).replace(/\0.*$/, '').trim(), 8) || 0;
+    yield { name, content: data.slice(offset + 512, offset + 512 + size) };
+    offset += 512 + Math.ceil(size / 512) * 512;
+  }
+}
+
+const sysroot = fs.readFileSync(path.join(clangDir, 'sysroot.tar'));
+
+function setUpSysroot(module) {
+  for (const { name, content } of tarContents(sysroot)) {
+    if (name.endsWith('/')) continue;
+    const directory = name.split('/').slice(0, -1).join('/');
+    if (directory && !module.FS.analyzePath(directory).exists) module.FS.mkdirTree(directory);
+    module.FS.writeFile(name, content);
+  }
+}
+
+async function createTool(factory, wasmName, program, capture) {
+  return factory({
+    thisProgram: program,
+    wasmBinary: fs.readFileSync(path.join(clangDir, wasmName)),
+    locateFile: (name) => path.join(clangDir, name),
+    print: capture,
+    printErr: capture,
+  });
+}
+
+async function compileAndLink(source) {
+  await ensureTools();
+  let driverOutput = '';
+  const driver = await createTool(globalThis.createClangModule, 'clang.wasm', 'clang++', (line) => {
+    driverOutput += `${line}\n`;
+  });
+  driver.FS.writeFile('main.cpp', source);
+  driver.FS.mkdirTree('/lib/wasm32-wasi');
+  driver.FS.mkdirTree('/include/c++/v1');
+  driver.FS.writeFile('/lib/wasm32-wasi/crt1-command.o', new Uint8Array(0));
+  driver.FS.writeFile('/lib/wasm32-wasi/crt1-reactor.o', new Uint8Array(0));
+  assert.equal(callMain(driver, ['main.cpp', '-std=c++20', '-Wall', '-Wextra', '-fno-exceptions', '-###']), 0);
+
+  const plan = parseCompilePlan(driverOutput);
+  let compilerOutput = '';
+  const compiler = await createTool(globalThis.createClangModule, 'clang.wasm', 'clang++', (line) => {
+    compilerOutput += `${line}\n`;
+  });
+  compiler.FS.writeFile('main.cpp', source);
+  setUpSysroot(compiler);
+  compiler.FS.mkdirTree('/tmp');
+  assert.equal(callMain(compiler, plan.compileSteps[0].args), 0, compilerOutput);
+
+  let linkerOutput = '';
+  const linker = await createTool(globalThis.createLLDModule, 'lld.wasm', 'wasm-ld', (line) => {
+    linkerOutput += `${line}\n`;
+  });
+  setUpSysroot(linker);
+  linker.FS.mkdirTree('/tmp');
+  linker.FS.writeFile(plan.compileSteps[0].objectPath, compiler.FS.readFile(plan.compileSteps[0].objectPath));
+
+  const status = callMain(linker, plan.linkStep.args);
+  return {
+    status,
+    diagnostics: linkerOutput,
+    output: status === 0 ? linker.FS.readFile(plan.linkStep.outputPath) : null,
+  };
+}
+
+async function run(binary) {
+  let stdout = '';
+  const runtime = createWasiRuntime({
+    stdin: { mode: 'none' },
+    onStdout: (text) => { stdout += text; },
+  });
+  runtime.initRunVfs();
+  const { instance } = await WebAssembly.instantiate(binary, {
+    wasi_snapshot_preview1: runtime.wasi,
+  });
+  runtime.setMemory(instance.exports.memory);
+  try {
+    instance.exports._start();
+  } catch (error) {
+    if (!error?.__wasi_exit__) throw error;
+    assert.equal(error.code, 0);
+  }
+  return stdout;
+}
+
+test('e2e: stream insertion of defined int and string return values links without C++ exception symbols', async () => {
+  const result = await compileAndLink(`#include <iostream>
+#include <string>
+
+int val() { return 5; }
+std::string label() { return "stream"; }
+
+int main() {
+  std::cout << val() << ' ' << label() << std::endl;
+}
+`);
+
+  assert.equal(result.status, 0, result.diagnostics);
+  assert.doesNotMatch(result.diagnostics, /undefined symbol: __cxa_/);
+  assert.match(await run(result.output), /5 stream/);
+});
+
+test('e2e: an undefined streamed function reports the user symbol at link time', async () => {
+  const result = await compileAndLink(`#include <iostream>
+
+int missing();
+
+int main() {
+  std::cout << missing() << std::endl;
+}
+`);
+
+  assert.notEqual(result.status, 0);
+  assert.match(result.diagnostics, /undefined symbol: .*missing/);
+  assert.doesNotMatch(result.diagnostics, /undefined symbol: __cxa_/);
+});

scripts/smoke-browser.mjs

@@ -287,6 +287,33 @@ async function evaluate(cdp, sessionId, expression, { awaitPromise = false } = {
   return result.result?.value;
 }
 
+async function replaceEditorText(cdp, sessionId, source) {
+  const focused = await evaluate(
+    cdp,
+    sessionId,
+    `(() => {
+      const input = document.querySelector('.monaco-editor textarea.inputarea');
+      if (!input) return false;
+      input.focus();
+      return document.activeElement === input;
+    })()`
+  );
+  assert(focused, 'Could not focus the Monaco editor input area');
+  const selectAllModifier = await evaluate(
+    cdp,
+    sessionId,
+    `navigator.platform.includes('Mac') ? 4 : 2`
+  );
+
+  await cdp.send('Input.dispatchKeyEvent', {
+    type: 'keyDown', key: 'a', code: 'KeyA', modifiers: selectAllModifier,
+  }, sessionId);
+  await cdp.send('Input.dispatchKeyEvent', {
+    type: 'keyUp', key: 'a', code: 'KeyA', modifiers: selectAllModifier,
+  }, sessionId);
+  await cdp.send('Input.insertText', { text: source }, sessionId);
+}
+
 async function openExtensionPage(cdp, extensionId) {
   const { targetId } = await cdp.send('Target.createTarget', {
     url: 'about:blank',
@@ -708,6 +735,10 @@ async function runHostedSmoke(cdp, { realRun = false } = {}) {
   await cdp.send('Runtime.enable', {}, sessionId);
   const runtimeProgram = `#include <fstream>
 #include <iostream>
+#include <string>
+
+int val() { return 5; }
+std::string label() { return "stream"; }
 
 int main() {
   std::fstream out;
@@ -718,7 +749,7 @@ int main() {
   }
   out << "hello from fstream\\n";
   out.close();
-  std::cout << "wrote output.txt\\n";
+  std::cout << val() << ' ' << label() << " wrote output.txt\\n";
   return 0;
 }
 `;
@@ -819,6 +850,7 @@ int main() {
 
   const createdFileText = await evaluate(cdp, sessionId, `globalThis.__browserCppTestFs.readText('output.txt')`);
   assert(createdFileText === 'hello from fstream\n', `Expected output.txt to be created, got: ${JSON.stringify(createdFileText)}`);
+  assert(terminalText.includes('5 stream wrote output.txt'), `Expected stream-insertion output, got: ${JSON.stringify(terminalText)}`);
 
   const explorerPath = await waitFor(async () => {
     return evaluate(
@@ -954,13 +986,25 @@ async function runSmoke(cdp, sessionId) {
   const hasEditor = await evaluate(cdp, sessionId, `!!document.querySelector('.monaco-editor')`);
   assert(hasEditor, 'Monaco editor did not render');
 
+  await replaceEditorText(cdp, sessionId, `#include <iostream>
+#include <string>
+
+int val() { return 5; }
+std::string label() { return "stream"; }
+
+int main() {
+  std::cout << val() << ' ' << label() << std::endl;
+  return 0;
+}
+`);
+
   await evaluate(cdp, sessionId, `document.getElementById('btn-compile-run').click()`);
 
   try {
     await waitFor(async () => {
       const text = await evaluate(cdp, sessionId, `document.body.textContent || ''`);
-      return text.includes('Compilation successful.') && text.includes('Hello, World!') ? text : null;
-    }, 'default C++ compile-and-run output', 120_000);
+      return text.includes('Compilation successful.') && text.includes('5 stream') ? text : null;
+    }, 'stream insertion compile-and-run output', 120_000);
   } catch (err) {
     const status = await evaluate(cdp, sessionId, `document.getElementById('status-compiler')?.textContent || ''`);
     const terminalText = await evaluate(cdp, sessionId, `document.getElementById('terminal-container')?.textContent || ''`);

src/workers/compiler.worker.js

@@ -376,7 +376,10 @@ async function compile(request) {
 
   if (sources.length === 0) return fail('No source files to compile.');
 
-  const userFlags = [`-std=${std}`, '-Wall', '-Wextra', ...flags];
+  // The bundled WASI libc++abi is built without C++ exception support. Clang
+  // otherwise enables exceptions for C++ sources, producing unresolved
+  // __cxa_* symbols when stream operations instantiate throwing paths.
+  const userFlags = [`-std=${std}`, '-Wall', '-Wextra', ...flags, '-fno-exceptions'];
 
   // ── Step 1: Build-plan discovery ─────────────────────────────────────────
   let plan;