Cargo extension for compiling Rust to MASM

Cargo.toml

@@ -17,7 +17,7 @@ members = [
   "tests/rust-apps/*",
   "tests/integration",
 ]
-exclude = ["tests/rust-apps-wasm"]
+exclude = ["tests/rust-apps-wasm", "cargo-ext/tests/data"]
 
 [workspace.package]
 version = "0.1.0"
@@ -78,7 +78,6 @@ midenc-driver = { path = "midenc-driver" }
 midenc-session = { path = "midenc-session" }
 miden-integration-tests = { path = "tests/integration" }
 
-
 [profile.dev]
 lto = false
 # Needed for 'inventory' to work

frontend-wasm/src/config.rs

@@ -1,3 +1,14 @@
 /// Configuration for the WASM translation.
-#[derive(Debug, Default)]
-pub struct WasmTranslationConfig {}
+#[derive(Debug)]
+pub struct WasmTranslationConfig {
+    /// The module name to use if Wasm module doesn't have one.
+    pub module_name_fallback: String,
+}
+
+impl Default for WasmTranslationConfig {
+    fn default() -> Self {
+        Self {
+            module_name_fallback: "noname".to_string(),
+        }
+    }
+}

frontend-wasm/src/module_env.rs

@@ -113,9 +113,9 @@ pub struct ModuleEnvironment<'a> {
 
 impl<'a> ModuleEnvironment<'a> {
     /// Creates a new `ModuleEnvironment` instance.
-    pub fn new() -> Self {
+    pub fn new(name: String) -> Self {
         Self {
-            info: ModuleInfo::new(Ident::with_empty_span(Symbol::intern("noname"))),
+            info: ModuleInfo::new(Ident::with_empty_span(Symbol::intern(name))),
             trans: FuncTranslator::new(),
             function_bodies: PrimaryMap::new(),
             data_segments: PrimaryMap::new(),

frontend-wasm/src/module_translator.rs

@@ -32,10 +32,10 @@ struct WasmTranslationResult {
 /// Translate a sequence of bytes forming a valid Wasm binary into Miden IR
 fn translate_module_inner(
     wasm: &[u8],
-    _config: &WasmTranslationConfig,
+    config: &WasmTranslationConfig,
     diagnostics: &DiagnosticsHandler,
 ) -> WasmResult<WasmTranslationResult> {
-    let mut module_env = ModuleEnvironment::new();
+    let mut module_env = ModuleEnvironment::new(config.module_name_fallback.clone());
     let env = &mut module_env;
     let wasm_features = WasmFeatures::default();
     let mut validator = Validator::new_with_features(wasm_features);

midenc-compile/src/stages/codegen.rs

@@ -26,9 +26,8 @@ impl Stage for CodegenStage {
         match input {
             MaybeLinked::Linked(program) => {
                 let mut convert_to_masm = masm::ConvertHirToMasm::<hir::Program>::default();
-                Ok(convert_to_masm
-                    .convert(program, analyses, session)
-                    .map(Compiled::Program)?)
+                let program = convert_to_masm.convert(program, analyses, session)?;
+                Ok(Compiled::Program(program))
             }
             MaybeLinked::Unlinked(modules) => {
                 let mut convert_to_masm = masm::ConvertHirToMasm::<hir::Module>::default();

midenc-compile/src/stages/mod.rs

@@ -3,7 +3,7 @@ use crate::{CompilerError, CompilerResult};
 use miden_codegen_masm as masm;
 use miden_frontend_wasm as wasm;
 use miden_hir::pass::{AnalysisManager, ConversionPass, RewritePass};
-use miden_hir::{self as hir, parser::ast, PassInfo};
+use miden_hir::{self as hir, parser::ast};
 use midenc_session::Session;
 
 mod codegen;

midenc-compile/src/stages/parse.rs

@@ -1,5 +1,6 @@
 use midenc_session::InputFile;
 use std::path::Path;
+use wasm::WasmTranslationConfig;
 
 use super::*;
 
@@ -35,9 +36,15 @@ impl Stage for ParseStage {
                 FileType::Wasm => self.parse_hir_from_wasm_file(path.as_ref(), &session),
                 unsupported => unreachable!("unsupported file type: {unsupported}"),
             },
-            InputType::Stdin { ref input, .. } => match file_type {
+            InputType::Stdin { name, ref input } => match file_type {
                 FileType::Hir => self.parse_ast_from_bytes(&input, &session),
-                FileType::Wasm => self.parse_hir_from_wasm_bytes(&input, &session),
+                FileType::Wasm => self.parse_hir_from_wasm_bytes(
+                    &input,
+                    &session,
+                    &WasmTranslationConfig {
+                        module_name_fallback: name.to_string().clone(),
+                    },
+                ),
                 unsupported => unreachable!("unsupported file type: {unsupported}"),
             },
         }
@@ -80,16 +87,20 @@ impl ParseStage {
         let mut file = std::fs::File::open(path)?;
         let mut bytes = Vec::with_capacity(1024);
         file.read_to_end(&mut bytes)?;
-        self.parse_hir_from_wasm_bytes(&bytes, session)
+        let file_name = path.file_name().unwrap().to_str().unwrap().to_owned();
+        let config = wasm::WasmTranslationConfig {
+            module_name_fallback: file_name,
+        };
+        self.parse_hir_from_wasm_bytes(&bytes, session, &config)
     }
 
     fn parse_hir_from_wasm_bytes(
         &self,
         bytes: &[u8],
         session: &Session,
+        config: &WasmTranslationConfig,
     ) -> CompilerResult<ParseOutput> {
-        let config = wasm::WasmTranslationConfig::default();
-        let module = wasm::translate_module(bytes, &config, &session.diagnostics)?;
+        let module = wasm::translate_module(bytes, config, &session.diagnostics)?;
 
         Ok(ParseOutput::Hir(Box::new(module)))
     }

midenc-compile/src/stages/rewrite.rs

@@ -26,10 +26,12 @@ impl Stage for ApplyRewritesStage {
         let matches = session.matches();
         for rewrite in inventory::iter::<RewritePassRegistration<hir::Module>> {
             let flag = rewrite.name();
-            if let Some(index) = matches.index_of(flag) {
-                let is_enabled = matches.get_flag(flag);
-                if is_enabled {
-                    registered.push((index, rewrite.get()));
+            if matches.try_contains_id(flag).is_ok() {
+                if let Some(index) = matches.index_of(flag) {
+                    let is_enabled = matches.get_flag(flag);
+                    if is_enabled {
+                        registered.push((index, rewrite.get()));
+                    }
                 }
             }
         }
@@ -41,10 +43,7 @@ impl Stage for ApplyRewritesStage {
         // Otherwise, assume that the intent was to skip those rewrites and do not add them
         let mut rewrites = RewriteSet::default();
         if registered.is_empty() {
-            let convert_to_masm_flag = <masm::ConvertHirToMasm<hir::Module> as PassInfo>::FLAG;
-            let convert_to_masm = matches.get_flag(convert_to_masm_flag);
-
-            if convert_to_masm {
+            if session.should_codegen() {
                 rewrites.push(ModuleRewritePassAdapter::new(
                     transforms::SplitCriticalEdges,
                 ));

midenc-session/src/lib.rs

@@ -285,13 +285,17 @@ impl Session {
         if self.should_emit(output_type) {
             match self.output_files.path(output_type) {
                 OutputFile::Real(path) => {
-                    let path = if let Some(name) = item.name() {
-                        path.with_file_name(name.as_str())
+                    let file_path = if path.is_dir() {
+                        let item_name = item
+                            .name()
+                            .map(|s| s.to_string())
+                            .unwrap_or("noname".to_string());
+                        path.join(item_name.as_str())
                             .with_extension(output_type.extension())
                     } else {
                         path
                     };
-                    item.write_to_file(&path)?;
+                    item.write_to_file(&file_path)?;
                 }
                 OutputFile::Stdout => {
                     item.write_to_stdout()?;

tools/cargo-miden/Cargo.toml

@@ -0,0 +1,41 @@
+[package]
+name = "cargo-miden"
+version.workspace = true
+rust-version.workspace = true
+authors.workspace = true
+description.workspace = true
+repository.workspace = true
+homepage.workspace = true
+documentation.workspace = true
+categories.workspace = true
+keywords.workspace = true
+license.workspace = true
+readme.workspace = true
+edition.workspace = true
+publish.workspace = true
+autotests = false # disable autodiscovery of tests
+
+[[bin]]
+name = "cargo-miden"
+
+[[test]]
+name = "integration"
+path = "tests/mod.rs"
+
+[dependencies]
+midenc-compile.workspace = true
+midenc-session.workspace = true
+miden-diagnostics.workspace = true
+env_logger.workspace = true
+log.workspace = true
+clap.workspace = true
+anyhow.workspace = true
+cargo-component = "0.5"
+cargo-component-core = "0.5"
+cargo_metadata = "0.18"
+cargo-generate = "0.18"
+semver = "1.0.20"
+parse_arg = "0.1.4"
+path-absolutize = "3.1.1"
+
+[dev-dependencies]

tools/cargo-miden/README.md

@@ -0,0 +1,42 @@
+# Miden Cargo Extension
+
+This crate provides a cargo extension that allows you to compile Rust code to Miden VM MASM.
+
+## Installation
+
+To install the extension, run:
+
+```bash
+cargo install cargo-miden
+```
+
+## Usage
+
+### Getting help
+To get help with the extension, run:
+
+```bash
+cargo miden
+```
+
+Or for help with a specific command:
+
+```bash
+cargo miden <command> --help
+```
+
+### Creating a new project
+To create a new Miden VM project, run:
+
+```bash
+cargo miden new <project-name>
+```
+
+### Compiling a project
+To compile a Rust crate to Miden VM MASM, run:
+
+```bash
+cargo miden build 
+```
+
+Without any additional arguments, this will compile the library target in the target directory in the `miden` folder.

tools/cargo-miden/src/build.rs

@@ -0,0 +1,64 @@
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+use anyhow::{bail, Context};
+use miden_diagnostics::Verbosity;
+use midenc_session::{
+    InputFile, OutputFile, OutputType, OutputTypeSpec, OutputTypes, ProjectType, Session, TargetEnv,
+};
+
+pub fn build_masm(
+    wasm_file_path: &Path,
+    output_folder: &Path,
+    is_bin: bool,
+) -> anyhow::Result<PathBuf> {
+    let project_type = if is_bin {
+        ProjectType::Program
+    } else {
+        ProjectType::Library
+    };
+
+    if !output_folder.exists() {
+        bail!(
+            "MASM output folder '{}' does not exist.",
+            output_folder.to_str().unwrap()
+        );
+    }
+    log::debug!(
+        "Compiling '{}' Wasm to '{}' directory with midenc ...",
+        wasm_file_path.to_str().unwrap(),
+        &output_folder.to_str().unwrap()
+    );
+    let input = InputFile::from_path(wasm_file_path).context("Invalid input file")?;
+    let output_file_folder = OutputFile::Real(output_folder.to_path_buf());
+    let output_type = OutputType::Masm;
+    let output_types = OutputTypes::new(vec![OutputTypeSpec {
+        output_type,
+        path: Some(output_file_folder.clone()),
+    }]);
+    let cwd = std::env::current_dir().context("Failed to get current working directory")?;
+    let options = midenc_session::Options::new(cwd)
+        // .with_color(color)
+        .with_verbosity(Verbosity::Debug)
+        // .with_warnings(self.warn)
+        .with_output_types(output_types);
+    let target = TargetEnv::default();
+    let session = Arc::new(
+        Session::new(
+            target,
+            input,
+            Some(output_folder.to_path_buf()),
+            None,
+            None,
+            options,
+            None,
+        )
+        .with_project_type(project_type),
+    );
+    midenc_compile::compile(session.clone()).context("Wasm to MASM compilation failed!")?;
+    let mut output_path = output_folder.join(wasm_file_path.file_stem().unwrap());
+    output_path.set_extension(output_type.extension());
+    Ok(output_path)
+}