Display panic payloads and locations in wasm demo

Author: ictrobot

crates/aoc_wasm/src/lib.rs

@@ -7,6 +7,7 @@ use aoc::all_puzzles;
 use aoc::utils::input::InputType;
 use std::error::Error;
 use std::ffi::CStr;
+use std::sync::Once;
 
 const BUFFER_LENGTH: usize = 1024 * 1024;
 
@@ -17,6 +18,8 @@ static mut PART1: [u8; BUFFER_LENGTH] = [0u8; BUFFER_LENGTH];
 #[unsafe(no_mangle)]
 static mut PART2: [u8; BUFFER_LENGTH] = [0u8; BUFFER_LENGTH];
 
+static ONCE_PANIC_HANDLER: Once = Once::new();
+
 #[unsafe(no_mangle)]
 extern "C" fn run_puzzle(
     year: u16,
@@ -25,17 +28,44 @@ extern "C" fn run_puzzle(
     run_part1: bool,
     run_part2: bool,
 ) -> bool {
+    ONCE_PANIC_HANDLER.call_once(|| {
+        std::panic::set_hook(Box::new(|info| {
+            let payload = info.payload();
+            let error: &str = if let Some(s) = payload.downcast_ref::<&str>() {
+                s
+            } else if let Some(s) = payload.downcast_ref::<String>() {
+                s
+            } else {
+                return;
+            };
+
+            let location = if let Some(location) = info.location() {
+                // Trying to format the location may cause another panic, particularly on allocation
+                // failure, but it should work on most explicit panics (e.g. "no solution found")
+                &format!(
+                    "{}:{}:{}",
+                    location.file(),
+                    location.line(),
+                    location.column()
+                )
+            } else {
+                ""
+            };
+
+            write_results(error, location);
+        }));
+    });
+
+    // Clear result buffers before running the solution, so if it panics, the buffers either contain
+    // the panic payload and location or are empty.
+    write_results("", "");
+
     let (success, part1, part2) = match run(year, day, is_example, run_part1, run_part2) {
         Ok((part1, part2)) => (true, part1, part2),
         Err(err) => (false, err.to_string(), String::new()),
     };
 
-    // SAFETY: No other Rust code accesses these variables or creates references - they're only read
-    // from JS.
-    unsafe {
-        write_string((&raw mut PART1).cast(), &part1);
-        write_string((&raw mut PART2).cast(), &part2);
-    }
+    write_results(&part1, &part2);
 
     success
 }
@@ -75,6 +105,15 @@ fn run(
     all_puzzles! {matcher}
 }
 
+fn write_results(part1: &str, part2: &str) {
+    // SAFETY: No other Rust code accesses these variables or creates references - they're only read
+    // from JS.
+    unsafe {
+        write_string((&raw mut PART1).cast(), part1);
+        write_string((&raw mut PART2).cast(), part2);
+    }
+}
+
 unsafe fn write_string(buf: *mut u8, str: &str) {
     let len = str.len().min(BUFFER_LENGTH - 1);
     unsafe {

crates/aoc_wasm/web/aoc.mjs

@@ -173,18 +173,39 @@ export class Aoc {
      * @param {boolean} [isExample]
      * @param {boolean} [part1]
      * @param {boolean} [part2]
-     * @return {{success: true, part1: string, part2: string} | {success: false, error: string}}
+     * @return {{success: true, part1: string, part2: string} | {success: false, error: string, stack?: string, panic_location?: string}}
      */
     run(year, day, input, isExample = false, part1 = true, part2 = true) {
         let success;
         try {
             this.#write(input);
             success = this.#exports.run_puzzle(year, day, isExample, part1, part2);
         } catch (e) {
-            this.newInstance();
-            return {
-                success: false,
-                error: "Unexpected error: " + e.toString() + (e.stack ? "\n\n" + e.stack : ""),
+            console.error(e);
+            let panic_payload = "";
+            let panic_location = "";
+            try {
+                panic_payload = this.#read("PART1");
+                panic_location = this.#read("PART2");
+            } catch (e2) {
+                console.warn(e2);
+            }
+
+            this.newInstance()
+
+            if (panic_payload.length > 0) {
+                return {
+                    success: false,
+                    error: "panic: " + panic_payload,
+                    panic_location,
+                    stack: e.stack,
+                }
+            } else {
+                return {
+                    success: false,
+                    error: e.toString(),
+                    stack: e.stack,
+                }
             }
         }
 

crates/aoc_wasm/web/web.mjs

@@ -1,6 +1,7 @@
 import {Aoc} from "./aoc.mjs";
 
-console.log("Commit", "${GIT_COMMIT}");
+const COMMIT = "${GIT_COMMIT}";
+console.log("Commit", COMMIT);
 
 const MODULE_PATHS = [
     "./aoc-simd128.wasm",
@@ -99,6 +100,35 @@ async function run(input, isExample, part) {
         const body = document.createElement("pre");
         body.classList.add("message-body", "is-family-monospace", "has-text-warning");
         body.innerText = result.error;
+        if (result.panic_location !== undefined && result.panic_location.length > 0) {
+            body.appendChild(document.createTextNode("\nat "));
+
+            const match = result.panic_location.match(/^crates\/([^\/]+)\/src\/(.+)[.]rs:(\d+):(\d+)$/);
+            if (match !== null) {
+                const [_, crate, path, line, _column] = match;
+
+                const rustdoc_link = document.createElement("a");
+                rustdoc_link.href = `doc/src/${crate}/${path}.rs.html#${line}`;
+                rustdoc_link.innerText = result.panic_location;
+                body.appendChild(rustdoc_link);
+
+                if (COMMIT.match(/^[0-9a-f]{40}$/)) {
+                    const github_link = document.createElement("a");
+                    github_link.href = `https://github.com/ictrobot/aoc-rs/blob/${COMMIT}/crates/${crate}/src/${path}.rs#L${line}`;
+                    github_link.innerText = "GitHub";
+
+                    body.appendChild(document.createTextNode(" ("));
+                    body.appendChild(github_link)
+                    body.appendChild(document.createTextNode(")"));
+                }
+            } else {
+                body.appendChild(document.createTextNode(result.panic_location));
+            }
+        }
+        if (result.stack !== undefined && result.stack.length > 0) {
+            body.appendChild(document.createTextNode("\n\n" + result.stack));
+        }
+
         article.appendChild(body);
     }