mir

Author: shepmaster

orchestrator/src/coordinator.rs

@@ -195,7 +195,7 @@ impl Container {
         };
 
         let write_main = self.commander.one(write_main);
-        let modify_cargo_toml = modify_cargo_toml(&self.commander, request.edition);
+        let modify_cargo_toml = modify_cargo_toml(&self.commander, &request);
 
         let (write_main, modify_cargo_toml) = join!(write_main, modify_cargo_toml);
 
@@ -305,30 +305,30 @@ struct Commander {
 // Consider making this into a top-level message to the worker to avoid the roundtrip.
 async fn modify_cargo_toml(
     commander: &Commander,
-    edition: crate::sandbox::Edition,
+    request: &CompileRequest,
 ) -> Result<(), ModifyCargoTomlError> {
     use modify_cargo_toml_error::*;
 
     const PATH: &str = "Cargo.toml";
 
-    let request = ReadFileRequest {
+    let read_request = ReadFileRequest {
         path: PATH.to_owned(),
     };
-    let cargo_toml = commander.one(request).await.context(CouldNotReadSnafu)?;
+    let cargo_toml = commander.one(read_request).await.context(CouldNotReadSnafu)?;
 
     let cargo_toml = String::from_utf8(cargo_toml.0)?;
     let cargo_toml = toml::from_str(&cargo_toml)?;
 
-    let cargo_toml = modify_cargo_toml::set_edition(cargo_toml, edition.to_cargo_toml_key());
+    let cargo_toml = request.modify_cargo_toml(cargo_toml);
 
     let cargo_toml = toml::to_string(&cargo_toml)?;
     let cargo_toml = cargo_toml.into_bytes();
 
-    let request = WriteFileRequest {
+    let write_request = WriteFileRequest {
         path: PATH.to_owned(),
         content: cargo_toml,
     };
-    commander.one(request).await.context(CouldNotWriteSnafu)?;
+    commander.one(write_request).await.context(CouldNotWriteSnafu)?;
 
     Ok(())
 }
@@ -778,6 +778,10 @@ mod tests {
         //Coordinator::new_docker()
     }
 
+    fn new_compile_request() -> CompileRequest {
+        new_compile_mir_request()
+    }
+
     fn new_compile_assembly_request() -> CompileRequest {
         CompileRequest {
             target: CompileTarget::Assembly(
@@ -802,7 +806,7 @@ mod tests {
     fn new_compile_hir_request_for(edition: Edition) -> CompileRequest {
         CompileRequest {
             target: CompileTarget::Hir,
-            channel: Channel::Beta,
+            channel: Channel::Nightly,
             crate_type: CrateType::Library(LibraryType::Lib),
             mode: Mode::Release,
             edition,
@@ -838,8 +842,17 @@ mod tests {
         }
     }
 
-    fn new_compile_request() -> CompileRequest {
-        new_compile_mir_request()
+    fn new_compile_wasm_request() -> CompileRequest {
+        CompileRequest {
+            target: CompileTarget::Wasm,
+            channel: Channel::Nightly, // TODO: Can we run this on all channels now?
+            crate_type: CrateType::Library(LibraryType::Cdylib),
+            mode: Mode::Release,
+            edition: Edition::Rust2021,
+            tests: false,
+            backtrace: false,
+            code: r#"#[export_name = "inc"] pub fn inc(a: u8) -> u8 { a + 1 }"#.to_owned(),
+        }
     }
 
     #[tokio::test]
@@ -919,7 +932,6 @@ mod tests {
         Ok(())
     }
 
-
     #[tokio::test]
     #[snafu::report]
     async fn test_compile_assembly() -> Result<()> {
@@ -983,6 +995,26 @@ mod tests {
         Ok(())
     }
 
+    #[tokio::test]
+    #[snafu::report]
+    async fn test_compile_wasm() -> Result<()> {
+        // cargo-wasm only exists inside the container
+        let coordinator = Coordinator::new_docker()?;
+
+        let response = coordinator
+            .compile(new_compile_wasm_request())
+            .with_timeout()
+            .await
+            .unwrap();
+
+        assert!(response.success, "stderr: {}", response.stderr);
+        assert_contains!(response.code, r#"(func $inc (export "inc") (type $t0) (param $p0 i32) (result i32)"#);
+
+        coordinator.shutdown().await?;
+
+        Ok(())
+    }
+
     trait TimeoutExt: Future + Sized {
         fn with_timeout(
             self,

orchestrator/src/sandbox.rs

@@ -84,6 +84,26 @@ pub enum CrateType {
     Library(LibraryType),
 }
 
+impl CrateType {
+    pub(crate) fn to_cargo_toml_key(&self) -> &'static str {
+        use {CrateType::*, LibraryType::*};
+
+        match self {
+            Binary => "bin",
+            Library(Lib) => "lib",
+            Library(Dylib) => "dylib",
+            Library(Rlib) => "rlib",
+            Library(Staticlib) => "staticlib",
+            Library(Cdylib) => "cdylib",
+            Library(ProcMacro) => "proc-macro",
+        }
+    }
+
+    pub(crate) fn to_library_cargo_toml_key(&self) -> Option<&'static str> {
+        if *self == Self::Binary { None } else { Some(self.to_cargo_toml_key()) }
+    }
+}
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum LibraryType {
     Lib,
@@ -123,7 +143,7 @@ impl CompileRequest {
         use CompileTarget::*;
 
         let mut args = if let Wasm = self.target {
-            vec!["wasm", "build"]
+            vec!["wasm"]
         } else {
             vec!["rustc"]
         };
@@ -133,8 +153,6 @@ impl CompileRequest {
 
         match self.target {
             Assembly(flavor, _, _) => {
-                use crate::sandbox::AssemblyFlavor::*;
-
                 args.extend(&["--", "--emit", "asm=compilation"]);
 
                 // Enable extra assembly comments for nightly builds
@@ -145,8 +163,8 @@ impl CompileRequest {
 
                 args.push("-C");
                 match flavor {
-                    Att => args.push("llvm-args=-x86-asm-syntax=att"),
-                    Intel => args.push("llvm-args=-x86-asm-syntax=intel"),
+                    AssemblyFlavor::Att => args.push("llvm-args=-x86-asm-syntax=att"),
+                    AssemblyFlavor::Intel => args.push("llvm-args=-x86-asm-syntax=intel"),
                 }
             }
             LlvmIr => args.extend(&["--", "--emit", "llvm-ir=compilation"]),
@@ -167,6 +185,27 @@ impl CompileRequest {
         }
     }
 
+    pub(crate) fn modify_cargo_toml(&self, mut cargo_toml: toml::Value) -> toml::Value {
+        cargo_toml = modify_cargo_toml::set_edition(cargo_toml, self.edition.to_cargo_toml_key());
+
+        // TODO: When we boot the container, grab information like
+        // `Cargo.toml` (and the `rustc` version, dependency
+        // versions?). Then we always start from that version.
+
+        // TODO: We need to undo these changes when switching back from a library
+        if let Some(crate_type) = self.crate_type.to_library_cargo_toml_key() {
+            cargo_toml = modify_cargo_toml::set_crate_type(cargo_toml, crate_type);
+        }
+
+        // TODO: We need to undo these changes when switching back from Wasm
+        if CompileTarget::Wasm == self.target {
+            cargo_toml = modify_cargo_toml::remove_dependencies(cargo_toml);
+            cargo_toml = modify_cargo_toml::set_release_lto(cargo_toml, true);
+        }
+
+        cargo_toml
+    }
+
     pub(crate) fn postprocess_result(&self, mut code: String) -> String {
         if let CompileTarget::Assembly(_, demangle, process) = self.target {
             if demangle == DemangleAssembly::Demangle {