chore: add Wasm component translation support to the integration tests;

Add Wasm component translation support to `CompileTest`.
Draft a text representation of the IR `Component` and use it in the
expected tests.

Author: greenhat

Cargo.lock

@@ -28,7 +28,13 @@ fn rust_array() {
     test.expect_wasm(expect_file!["./expected/array.wat"]);
     test.expect_ir(expect_file!["./expected/array.hir"]);
     assert!(
-        test.hir.unwrap().segments().last().unwrap().is_readonly(),
+        test.hir
+            .unwrap()
+            .unwrap_program()
+            .segments()
+            .last()
+            .unwrap()
+            .is_readonly(),
         "data segment should be readonly"
     );
 }
@@ -39,7 +45,14 @@ fn rust_static_mut() {
     test.expect_wasm(expect_file!["./expected/static_mut.wat"]);
     test.expect_ir(expect_file!["./expected/static_mut.hir"]);
     assert!(
-        !test.hir.unwrap().segments().last().unwrap().is_readonly(),
+        !test
+            .hir
+            .unwrap()
+            .unwrap_program()
+            .segments()
+            .last()
+            .unwrap()
+            .is_readonly(),
         "data segment should be mutable"
     );
 }

frontend-wasm/tests/test_rust_comp.rs

@@ -1363,3 +1363,12 @@ impl MastRootHash {
         &self.0
     }
 }
+
+impl fmt::Display for MastRootHash {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        for byte in &self.0 {
+            write!(f, "{:02x}", byte)?;
+        }
+        Ok(())
+    }
+}

hir/src/asm/isa.rs

@@ -35,3 +35,9 @@ impl InterfaceFunctionIdent {
         }
     }
 }
+
+impl std::fmt::Display for InterfaceFunctionIdent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}::{}", self.interface.full_name, self.function)
+    }
+}

hir/src/component/interface.rs

@@ -21,6 +21,15 @@ pub enum FunctionInvocationMethod {
     Exec,
 }
 
+impl fmt::Display for FunctionInvocationMethod {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            FunctionInvocationMethod::Call => write!(f, "\"call\""),
+            FunctionInvocationMethod::Exec => write!(f, "\"exec\""),
+        }
+    }
+}
+
 /// A component import
 #[derive(Debug)]
 pub struct ComponentImport {
@@ -34,6 +43,19 @@ pub struct ComponentImport {
     pub function_mast_root_hash: MastRootHash,
 }
 
+impl fmt::Display for ComponentImport {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "{} {} {} mast#0x{}",
+            self.invoke_method,
+            self.interface_function,
+            self.function_ty,
+            self.function_mast_root_hash
+        )
+    }
+}
+
 /// The name of a exported function
 #[derive(Debug, Ord, PartialEq, PartialOrd, Eq, Hash, derive_more::From, derive_more::Into)]
 pub struct FunctionExportName(Symbol);
@@ -99,6 +121,26 @@ impl Component {
     }
 }
 
+impl fmt::Display for Component {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(f, "component")?;
+        writeln!(f, "")?;
+        for (function_id, import) in self.imports.iter() {
+            writeln!(f, "import {import} lower {function_id}",)?;
+        }
+        writeln!(f, "")?;
+        for module in self.modules.iter() {
+            // temporary hack to separate modules, until curly braces and indentation are implemented
+            writeln!(
+                f,
+                "// ===================================================================="
+            )?;
+            writeln!(f, "{}", module)?;
+        }
+        Ok(())
+    }
+}
+
 /// This struct provides an ergonomic way to construct a [Component] in an imperative fashion.
 ///
 /// Simply create the builder, add/build one or more modules, then call `link` to obtain a [Component].

hir/src/component/mod.rs

@@ -233,6 +233,29 @@ pub struct LiftedFunctionType {
     pub results: Vec<Type>,
 }
 
+impl fmt::Display for LiftedFunctionType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "fn(")?;
+        for (i, param) in self.params.iter().enumerate() {
+            if i > 0 {
+                write!(f, ", ")?;
+            }
+            write!(f, "{}", param)?;
+        }
+        write!(f, ")")?;
+        if !self.results.is_empty() {
+            write!(f, " -> ")?;
+            for (i, result) in self.results.iter().enumerate() {
+                if i > 0 {
+                    write!(f, ", ")?;
+                }
+                write!(f, "{}", result)?;
+            }
+        }
+        Ok(())
+    }
+}
+
 /// An [ExternalFunction] represents a function whose name and signature are known,
 /// but which may or may not be compiled as part of the current translation unit.
 ///

hir/src/function.rs

@@ -27,6 +27,7 @@ wasmprinter = "0.2.63"
 sha2 = "0.10"
 rustc-demangle = {version = "0.1.19", features = ["std"]}    
 cargo_metadata = "0.18"
+derive_more.workspace = true
 
 [dev-dependencies]
 proptest.workspace = true