feat!: update cli, use ts for utils

Author: glebbash

README.md

@@ -71,9 +71,9 @@ Here are some of them with syntax highlighting from the [LO VS Code extension](#
 
 3️⃣ Using Node.js
 
-- Install [Node.js](https://github.com/bytecodealliance/wasmtime)
-- Compiling files: `./utils.mjs compile <input>.lo > <output>.wasm`
-- Compiling & running files: `./utils.mjs run <input>.lo`
+- Install [Node.js 22+](https://nodejs.org/)
+- Compiling files: `./utils.ts compile <input>.lo > <output>.wasm`
+- Compiling & running files: `./utils.ts run <input>.lo`
 
 ---
 

docs/README.md

@@ -329,8 +329,8 @@ fn main(): u32 {
 
 - Requirements:
   - Install [Node.js](https://nodejs.org/en/download/package-manager) for running tests
-- Run `./utils.mjs test`
+- Run `./utils.ts test`
 
-    > This runs tests defined in `utils.mjs`. Test programs are located in `examples/test`
+    > This runs tests defined in `utils.ts`. Test programs are located in `examples/test`
 
 > NOTE: there is currently no built-in testing solution in the compiler, existing test setup is good enough for now.

examples/lib/debug.lo

@@ -1,4 +1,4 @@
-// provided by utils.mjs
+// provided by utils.ts
 // useful for debugging when WASI fd_write is not available
 import from "console" {
     fn debug_u32::log(x: u32);

lo.wasm

@@ -371,7 +371,7 @@ struct LoConstDef {
 pub struct CodeGen {
     pub errors: LoErrorManager,
 
-    mode: CompilerMode,
+    mode: LoCommand,
     pub fm: FileManager,
 
     type_defs: Vec<LoTypeDef>,
@@ -396,7 +396,7 @@ pub struct CodeGen {
 }
 
 impl CodeGen {
-    pub fn new(mode: CompilerMode) -> Self {
+    pub fn new(mode: LoCommand) -> Self {
         let mut codegen = Self::default();
         codegen.mode = mode;
         codegen.type_defs.push(LoTypeDef {
@@ -478,7 +478,7 @@ impl CodeGen {
             loc: LoLocation::internal(),
         });
 
-        if codegen.mode == CompilerMode::Inspect {
+        if codegen.mode == LoCommand::Inspect {
             stdout_writeln("[");
         }
 
@@ -790,7 +790,7 @@ impl CodeGen {
                         GlobalDefValue::DataSize => LoType::U32,
                     };
 
-                    if self.mode == CompilerMode::Inspect {
+                    if self.mode == LoCommand::Inspect {
                         let global_name = &global.global_name.repr;
 
                         self.print_inspection(&InspectInfo {
@@ -821,7 +821,7 @@ impl CodeGen {
                     let mut const_ctx = LoExprContext::default();
                     let code_unit = self.build_code_unit(&mut const_ctx, &const_def.const_value)?;
 
-                    if self.mode == CompilerMode::Inspect {
+                    if self.mode == LoCommand::Inspect {
                         let const_name = &const_def.const_name.repr;
                         let const_type = &code_unit.lo_type;
 
@@ -1074,7 +1074,7 @@ impl CodeGen {
 
         wasm_module.types.append(&mut self.wasm_types.borrow_mut());
 
-        if self.mode == CompilerMode::Inspect {
+        if self.mode == LoCommand::Inspect {
             stdout_writeln("{ \"type\": \"end\" }");
             stdout_writeln("]");
         }
@@ -1429,7 +1429,7 @@ impl CodeGen {
 
             CodeExpr::Ident(ident) => {
                 if let Some(const_def) = self.get_const(ctx, &ident.repr) {
-                    if self.mode == CompilerMode::Inspect {
+                    if self.mode == LoCommand::Inspect {
                         self.print_inspection(&InspectInfo {
                             message: format!(
                                 "const {}: {}",
@@ -2097,7 +2097,7 @@ impl CodeGen {
             });
         }
 
-        if self.mode == CompilerMode::Inspect {
+        if self.mode == LoCommand::Inspect {
             let params = ListDisplay(&lo_fn_info.fn_params);
             let return_type = &lo_fn_info.fn_type.output;
             self.print_inspection(&InspectInfo {
@@ -2275,7 +2275,7 @@ impl CodeGen {
             Some(&mut lo_type_args),
         )?;
 
-        if self.mode == CompilerMode::Inspect {
+        if self.mode == LoCommand::Inspect {
             let lo_type_args = ListDisplay(&lo_type_args);
 
             let mut macro_args = Vec::new();
@@ -2926,7 +2926,7 @@ impl CodeGen {
         loc: LoLocation,
         linked_loc: Option<LoLocation>,
     ) -> LoVariableInfo {
-        let inspect_info = if self.mode == CompilerMode::Inspect {
+        let inspect_info = if self.mode == LoCommand::Inspect {
             Some(InspectInfo {
                 message: format!("let {}: {}", local_name, local_type),
                 loc: loc.clone(),
@@ -2962,7 +2962,7 @@ impl CodeGen {
             return Ok(LoVariableInfo::Global {
                 global_index: global.global_index,
                 global_type: global.global_type.clone(),
-                inspect_info: if self.mode == CompilerMode::Inspect {
+                inspect_info: if self.mode == LoCommand::Inspect {
                     Some(InspectInfo {
                         message: format!("global {}: {}", ident.repr, global.global_type),
                         loc: ident.loc.clone(),
@@ -2989,7 +2989,7 @@ impl CodeGen {
 
         let field = self.get_struct_or_struct_ref_field(ctx, &lhs_type, field_access)?;
 
-        let inspect_info = if self.mode == CompilerMode::Inspect {
+        let inspect_info = if self.mode == LoCommand::Inspect {
             Some(InspectInfo {
                 message: format!("{}.{}: {}", lhs_type, field.field_name, field.field_type),
                 loc: field_access.field_name.loc.clone(),
@@ -3148,7 +3148,7 @@ impl CodeGen {
         let addr_type = self.get_expr_type(ctx, addr_expr)?;
 
         if let LoType::Pointer { pointee } = &addr_type {
-            let inspect_info = if self.mode == CompilerMode::Inspect {
+            let inspect_info = if self.mode == LoCommand::Inspect {
                 Some(InspectInfo {
                     message: format!("<deref>: {}", pointee),
                     loc: op_loc.clone(),
@@ -3488,7 +3488,7 @@ impl CodeGen {
 
     // TODO: don't use tuples
     fn process_const_string(&self, value: String, loc: &LoLocation) -> Result<(u32, u32), LoError> {
-        if self.memory.is_none() && self.mode != CompilerMode::Inspect {
+        if self.memory.is_none() && self.mode != LoCommand::Inspect {
             return Err(LoError {
                 message: format!("Cannot use strings with no memory defined"),
                 loc: loc.clone(),
@@ -3533,7 +3533,7 @@ impl CodeGen {
 
     fn get_type_or_err(&self, type_name: &str, loc: &LoLocation) -> Result<LoType, LoError> {
         if let Some(typedef) = self.get_typedef(type_name) {
-            if self.mode == CompilerMode::Inspect {
+            if self.mode == LoCommand::Inspect {
                 if typedef.loc.file_index != 0 {
                     if typedef.type_alias {
                         self.print_inspection(&InspectInfo {

src/codegen.rs

@@ -2,13 +2,13 @@ use alloc::{fmt, format, string::String, vec, vec::Vec};
 use core::{cell::RefCell, default, ffi::CStr, str};
 
 #[derive(Default, PartialEq, Clone, Copy)]
-pub enum CompilerMode {
+pub enum LoCommand {
     #[default]
     Compile,
     Inspect,
-    PrettyPrint,
+    Format,
     Eval,
-    EvalWasm,
+    Wasi,
 }
 
 #[derive(PartialEq)]

src/core.rs

@@ -34,13 +34,12 @@ mod wasm_target {
 }
 
 static USAGE: &str = "\
-Usage: lo <file> [<mode>]
-  Where <mode> is either:
-    --compile (default if not provided)
-    --inspect
-    --pretty-print
-    --eval (experimental)
-    --eval-wasm (experimental)\
+Usage:
+  lo compile <input.lo>
+  lo inspect <input.lo>
+  lo format <input.lo>
+  lo eval <input.lo> (experimental)
+  lo wasi <input.lo> (experimental)\
 ";
 
 mod wasi_api {
@@ -65,41 +64,27 @@ mod wasi_api {
 
     fn start() -> Result<(), String> {
         let args = WasiArgs::load().unwrap();
-        if args.len() < 2 {
+        if args.len() < 3 {
             return Err(format!("{}", USAGE));
         }
 
-        let mut file_name = args.get(1).unwrap();
+        let command = match args.get(1).unwrap() {
+            "compile" => LoCommand::Compile,
+            "inspect" => LoCommand::Inspect,
+            "format" => LoCommand::Format,
+            "eval" => LoCommand::Eval,
+            "wasi" => LoCommand::Wasi,
+            unknown_command => {
+                return Err(format!("Unknown command: {unknown_command}\n{}", USAGE));
+            }
+        };
+
+        let mut file_name = args.get(2).unwrap();
         if file_name == "-i" {
             file_name = "<stdin>";
         }
 
-        let mut compiler_mode = CompilerMode::Compile;
-
-        if let Some(compiler_mode_arg) = args.get(2) {
-            match compiler_mode_arg {
-                "--compile" => {
-                    compiler_mode = CompilerMode::Compile;
-                }
-                "--inspect" => {
-                    compiler_mode = CompilerMode::Inspect;
-                }
-                "--pretty-print" => {
-                    compiler_mode = CompilerMode::PrettyPrint;
-                }
-                "--eval" => {
-                    compiler_mode = CompilerMode::Eval;
-                }
-                "--eval-wasm" => {
-                    compiler_mode = CompilerMode::EvalWasm;
-                }
-                unknown_mode => {
-                    return Err(format!("Unknown compiler mode: {unknown_mode}\n{}", USAGE));
-                }
-            }
-        }
-
-        if compiler_mode == CompilerMode::PrettyPrint {
+        if command == LoCommand::Format {
             let mut fm = FileManager::default();
             let included_file = fm
                 .include_file(file_name, &LoLocation::internal())
@@ -118,7 +103,7 @@ mod wasi_api {
             return Ok(());
         }
 
-        if compiler_mode == CompilerMode::EvalWasm {
+        if command == LoCommand::Wasi {
             let module_bytes = file_read(file_name)?;
 
             let wasm_module = WasmParser::parse(String::from(file_name), module_bytes)?;
@@ -128,11 +113,11 @@ mod wasi_api {
             return Ok(());
         }
 
-        if compiler_mode == CompilerMode::Inspect {
+        if command == LoCommand::Inspect {
             stdout_enable_buffering();
         }
 
-        let mut codegen = CodeGen::new(compiler_mode);
+        let mut codegen = CodeGen::new(command);
 
         let included_file = codegen
             .fm
@@ -141,7 +126,7 @@ mod wasi_api {
 
         let mut asts = Vec::new();
         parse_file_tree(
-            compiler_mode,
+            command,
             &mut codegen.fm,
             &mut asts,
             included_file.file_index,
@@ -165,27 +150,27 @@ mod wasi_api {
             .generate()
             .map_err(|err| err.to_string(&codegen.fm))?;
 
-        if compiler_mode == CompilerMode::Compile {
+        if command == LoCommand::Compile {
             let mut binary = Vec::new();
             wasm_module.dump(&mut binary);
             stdout_write(binary.as_slice());
         }
 
-        if compiler_mode == CompilerMode::Eval {
+        if command == LoCommand::Eval {
             WasmEval::eval(wasm_module).map_err(|err| err.message)?;
         }
 
         return Ok(());
     }
 
     fn parse_file_tree(
-        mode: CompilerMode,
+        mode: LoCommand,
         fm: &mut FileManager,
         asts: &mut Vec<AST>,
         file_index: u32,
         file_contents: String,
     ) -> Result<(), LoError> {
-        if mode == CompilerMode::Inspect {
+        if mode == LoCommand::Inspect {
             let file_path = fm.get_file_path(file_index);
             stdout_writeln(format!(
                 "{{ \"type\": \"file\", \
@@ -209,7 +194,7 @@ mod wasi_api {
                 parse_file_tree(mode, fm, asts, included_file.file_index, file_contents)?;
             }
 
-            if mode == CompilerMode::Inspect {
+            if mode == LoCommand::Inspect {
                 let source_index = file_index;
                 let source_range = RangeDisplay(&include.loc);
                 let target_index = included_file.file_index;