Add miden-package crate with Package type to represent a compiled Miden program/library.

CHANGELOG.md

@@ -15,6 +15,7 @@
 - Added `miden_core::mast::MastForest::advice_map` to load it into the advice provider before the `MastForest` execution (#1574).
 - Optimized the computation of the DEEP queries in the recursive verifier (#1594).
 - Added validity checks for the inputs to the recursive verifier (#1596).
+- Added `miden-package` crate with `Package` type to represent a compiled Miden program/library (#1544).
 
 ## 0.11.0 (2024-11-04)
 

Cargo.toml

@@ -4,6 +4,7 @@ members = [
     "assembly",
     "core",
     "miden",
+    "package",
     "processor",
     "prover",
     "stdlib",

assembly/src/ast/procedure/name.rs

@@ -1,10 +1,15 @@
-use alloc::{string::ToString, sync::Arc};
+use alloc::{
+    string::{String, ToString},
+    sync::Arc,
+};
 use core::{
     fmt,
     hash::{Hash, Hasher},
     str::FromStr,
 };
 
+use vm_core::utils::{ByteReader, ByteWriter, Deserializable, DeserializationError, Serializable};
+
 use crate::{
     ast::{CaseKindError, Ident, IdentError},
     diagnostics::{IntoDiagnostic, Report},
@@ -328,3 +333,47 @@ impl FromStr for ProcedureName {
         Ok(Self(Ident::new_unchecked(Span::unknown(raw))))
     }
 }
+
+impl Serializable for ProcedureName {
+    fn write_into<W: ByteWriter>(&self, target: &mut W) {
+        self.as_str().write_into(target)
+    }
+}
+
+impl Deserializable for ProcedureName {
+    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
+        let str: String = source.read()?;
+        let proc_name =
+            ProcedureName::new_unchecked(Ident::new_unchecked(Span::unknown(Arc::from(str))));
+        Ok(proc_name)
+    }
+}
+
+// TESTS
+// ================================================================================================
+
+/// Tests
+#[cfg(test)]
+mod tests {
+    use vm_core::{
+        debuginfo::Span,
+        utils::{Deserializable, Serializable},
+    };
+
+    use super::ProcedureName;
+    use crate::ast::Ident;
+
+    #[test]
+    fn procedure_name_serialization_rustc_mangled() {
+        // Tests that rustc mangled symbols are serialized and deserialized
+        // see https://doc.rust-lang.org/rustc/symbol-mangling/v0.html#symbol-grammar-summary
+        let all_possible_chars_in_mangled_name =
+            "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_.$";
+        let proc_name = ProcedureName::new_unchecked(Ident::new_unchecked(Span::unknown(
+            all_possible_chars_in_mangled_name.into(),
+        )));
+        let bytes = proc_name.to_bytes();
+        let deserialized = ProcedureName::read_from_bytes(&bytes).unwrap();
+        assert_eq!(proc_name, deserialized);
+    }
+}

assembly/src/library/mod.rs

@@ -7,13 +7,12 @@ use alloc::{
 
 use vm_core::{
     crypto::hash::RpoDigest,
-    debuginfo::Span,
     mast::{MastForest, MastNodeId},
     utils::{ByteReader, ByteWriter, Deserializable, DeserializationError, Serializable},
-    Kernel,
+    AdviceMap, Kernel,
 };
 
-use crate::ast::{Ident, ProcedureName, QualifiedProcedureName};
+use crate::ast::QualifiedProcedureName;
 
 mod error;
 mod module;
@@ -92,6 +91,16 @@ impl Library {
 
         Ok(Self { digest, exports, mast_forest })
     }
+
+    /// Produces a new library with the existing [`MastForest`] and provided advice map.
+    pub fn with_advice_map(self, advice_map: AdviceMap) -> Self {
+        let mut mast_forest = (*self.mast_forest).clone();
+        mast_forest.advice_map_mut().extend(advice_map);
+        Self {
+            mast_forest: Arc::new(mast_forest),
+            ..self
+        }
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -170,7 +179,7 @@ impl Serializable for Library {
         target.write_usize(exports.len());
         for (proc_name, proc_node_id) in exports {
             proc_name.module.write_into(target);
-            proc_name.name.as_str().write_into(target);
+            proc_name.name.write_into(target);
             target.write_u32(proc_node_id.as_u32());
         }
     }
@@ -187,10 +196,7 @@ impl Deserializable for Library {
         let mut exports = BTreeMap::new();
         for _ in 0..num_exports {
             let proc_module = source.read()?;
-            let proc_name: String = source.read()?;
-            let proc_name = ProcedureName::new_unchecked(Ident::new_unchecked(Span::unknown(
-                Arc::from(proc_name),
-            )));
+            let proc_name = source.read()?;
             let proc_name = QualifiedProcedureName::new(proc_module, proc_name);
             let proc_node_id = MastNodeId::from_u32_safe(source.read_u32()?, &mast_forest)?;
 

assembly/src/library/path.rs

@@ -10,6 +10,7 @@ use core::{
 };
 
 use smallvec::smallvec;
+use vm_core::debuginfo::SourceSpan;
 
 use crate::{
     ast::{Ident, IdentError},
@@ -505,7 +506,26 @@ impl Deserializable for LibraryPath {
         let path = source.read_slice(len)?;
         let path =
             str::from_utf8(path).map_err(|e| DeserializationError::InvalidValue(e.to_string()))?;
-        Self::new(path).map_err(|e| DeserializationError::InvalidValue(e.to_string()))
+        let path = LibraryPath::new(path).unwrap_or_else(|_| {
+            // Try to parse at least the namespace
+            match LibraryNamespace::strip_path_prefix(path) {
+                Ok((ns, rest)) => {
+                    let module_id = Ident::new_unchecked(Span::new(
+                        SourceSpan::default(),
+                        Arc::from(rest.to_string()),
+                    ));
+                    LibraryPath::new_from_components(ns, [module_id])
+                },
+                Err(_) => {
+                    let module_id = Ident::new_unchecked(Span::new(
+                        SourceSpan::default(),
+                        Arc::from(path.to_string()),
+                    ));
+                    LibraryPath::new_from_components(LibraryNamespace::Anon, [module_id])
+                },
+            }
+        });
+        Ok(path)
     }
 }
 
@@ -537,9 +557,16 @@ fn validate_component(component: &str) -> Result<(), PathError> {
 /// Tests
 #[cfg(test)]
 mod tests {
-    use vm_core::assert_matches;
+    use std::sync::Arc;
+
+    use vm_core::{
+        assert_matches,
+        debuginfo::{SourceSpan, Span},
+        utils::{Deserializable, Serializable},
+    };
 
     use super::{super::LibraryNamespaceError, IdentError, LibraryPath, PathError};
+    use crate::{alloc::string::ToString, ast::Ident, LibraryNamespace};
 
     #[test]
     fn new_path() {
@@ -588,4 +615,18 @@ mod tests {
             Err(PathError::InvalidNamespace(LibraryNamespaceError::InvalidStart))
         );
     }
+
+    #[test]
+    fn path_serialization_wasm_cm_style_module_name() {
+        // Tests that Wasm Component Model names are serialized and deserialized correctly
+        let wasm_cm_style_module_name = "namespace:package/[email protected]";
+        let module_id = Ident::new_unchecked(Span::new(
+            SourceSpan::default(),
+            Arc::from(wasm_cm_style_module_name.to_string()),
+        ));
+        let path = LibraryPath::new_from_components(LibraryNamespace::Anon, [module_id]);
+        let bytes = path.to_bytes();
+        let deserialized = LibraryPath::read_from_bytes(&bytes).unwrap();
+        assert_eq!(path, deserialized);
+    }
 }