refactor(wasm): Clean input unit test for wasm release.

Author: dylan-sutton-chavez

compiler/src/modules/vm/mod.rs

@@ -61,6 +61,7 @@ pub struct VM<'a> {
     pub output: Vec<String>,
     pub input_buffer: Vec<String>,
     pub event_queue: Vec<Val>,
+    pub strict_input: bool,
 }
 
 impl<'a> VM<'a> {
@@ -227,6 +228,7 @@ impl<'a> VM<'a> {
             pending_kw_delta: 0,
             yielded: false,
             resume_ip: 0,
+            strict_input: false,
             output: Vec::new(),
             input_buffer: Vec::new(),
             event_queue: Vec::new(),

compiler/src/wasm.rs

@@ -1,3 +1,7 @@
+#![cfg_attr(target_arch = "wasm32", no_std)] // Enables no_std only for WASM builds.
+
+extern crate alloc; // Enables heap allocation without the standard library.
+
 #[cfg(target_arch = "wasm32")]
 mod runtime {
     use lol_alloc::LeakingPageAllocator;
@@ -51,6 +55,7 @@ mod runtime {
         } else {
             crate::modules::vm::optimizer::constant_fold(&mut chunk);
             let mut vm = VM::with_limits(&chunk, Limits::sandbox());
+            vm.strict_input = true;
             // Feed input buffer from host
             let inp_len = unsafe { INP_LEN };
             if inp_len > 0 {
@@ -112,22 +117,31 @@ mod tests {
             assert!(errs.is_empty(), "parse error on {:?}: {:?}", case.src, errs.iter().map(|e| &e.msg).collect::<Vec<_>>());
 
             let mut vm = VM::new(&chunk);
+            vm.strict_input = true;
+            // Cases that supply an input buffer feed the VM normally; the
+            // strict_input flag only triggers when the VM tries to read past
+            // the end of the buffer (i.e. the WASM "no host data" path).
             vm.input_buffer = case.input.clone();
-            // WASM: input tests should produce a RuntimeError
-            let expect_input_error = case.input.len() > 0 && cfg!(target_arch = "wasm32");
+            let expects_input_error = case.input.is_empty()
+                && (case.src.contains("input(") || case.src.contains("input ("));
 
             match vm.run() {
                 Ok(_) => {
+                    assert!(
+                        !expects_input_error,
+                        "expected input() to error under WASM strict mode for: {:?}", case.src
+                    );
                     assert_eq!(vm.output, case.output, "output mismatch on: {:?}", case.src);
                 }
                 Err(e) => match &case.error {
                     Some(expected) => assert!(
                         e.to_string().contains(expected.as_str()),
                         "wrong error on {:?}: got '{}', expected '{}'", case.src, e, expected
                     ),
-                    None if expect_input_error => assert!(
+                    None if expects_input_error => assert!(
                         e.to_string().contains("input"),
-                        "expected input RuntimeError on wasm32 for: {:?}", case.src
+                        "expected input RuntimeError under WASM strict mode for: {:?}, got: {}",
+                        case.src, e
                     ),
                     None => panic!("VM error on {:?}: {}", case.src, e),
                 }

demo/style.css

@@ -1,17 +1,22 @@
+/* Layout & Scroll */
 /* Layout and Scroll */
 
+.no-scrollbar::-webkit-scrollbar { display: none }
+.no-scrollbar { -ms-overflow-style: none; scrollbar-width: none }
+#ed { tab-size: 4; white-space: pre !important; outline: 0; overflow: auto }
 .no-scrollbar::-webkit-scrollbar { display: none; }
 .no-scrollbar { -ms-overflow-style: none; scrollbar-width: none; }
 #ed { min-width: 0; tab-size: 4; white-space: pre !important; outline: none; font-variant-ligatures: none; overflow-x: auto; overflow-y: auto; }
 
 /* Type */
 
+.code-font { font: 1.625/1 'JetBrains Mono', 'Fira Code', monospace; font-variant-ligatures: none }
 .code-font {
     font-family: 'JetBrains Mono', 'Fira Code', ui-monospace, monospace;
     line-height: 1.625;
 }
 
-/* Syntax */
+/* Visibility */
 
 .tk-kw { color: #c586c0 }
 .tk-lit { color: #569cd6 }