feat(plugin): Add versioned wrapper struct (#7382)

Author: kwonoj

bindings/Cargo.lock

@@ -48,7 +48,7 @@ tracing-chrome = "0.5.0"
 tracing-futures = "0.2.5"
 tracing-subscriber = { version = "0.3.9", features = ["env-filter"] }
 
-swc_core = { version = "0.75.46", features = [
+swc_core = { version = "0.76.2", features = [
   "allocator_node",
   "ecma_ast",
   "ecma_ast_serde",

bindings/binding_core_node/Cargo.toml

@@ -34,7 +34,7 @@ plugin = []
 anyhow = "1.0.66"
 serde = { version = "1", features = ["derive"] }
 serde-wasm-bindgen = "0.4.5"
-swc_core = { version = "0.75.46", features = [
+swc_core = { version = "0.76.2", features = [
   "ecma_ast_serde",
   "common_perf",
   "binding_macro_wasm",

bindings/binding_core_wasm/Cargo.toml

@@ -27,7 +27,7 @@ relative-path = "1.6.1"
 serde = { version = "1", features = ["derive"] }
 serde_json = { version = "1", features = ["unbounded_depth"] }
 sourcemap = "6.2.2"
-swc_core = { version = "0.75.46", features = [
+swc_core = { version = "0.76.2", features = [
   "trace_macro",
   "common_concurrent",
   "base_concurrent",

bindings/swc_cli/Cargo.toml

@@ -94,7 +94,8 @@ impl RustPlugins {
             },
             || {
                 let span = tracing::span!(tracing::Level::INFO, "serialize_program").entered();
-                let mut serialized_program = PluginSerializedBytes::try_serialize(&n)?;
+                let program = swc_common::plugin::serialized::VersionedSerializable::new(n);
+                let mut serialized = PluginSerializedBytes::try_serialize(&program)?;
                 drop(span);
 
                 // Run plugin transformation against current program.
@@ -137,9 +138,9 @@ impl RustPlugins {
                         )
                         .entered();
 
-                        serialized_program = transform_plugin_executor
+                        serialized = transform_plugin_executor
                             .transform(
-                                &serialized_program,
+                                &serialized,
                                 self.unresolved_mark,
                                 should_enable_comments_proxy,
                             )
@@ -156,7 +157,7 @@ impl RustPlugins {
 
                 // Plugin transformation is done. Deserialize transformed bytes back
                 // into Program
-                serialized_program.deserialize()
+                serialized.deserialize().map(|v| v.into_inner())
             },
         )
     }
@@ -179,7 +180,8 @@ impl RustPlugins {
                 inner: self.comments.clone(),
             },
             || {
-                let mut serialized_program = PluginSerializedBytes::try_serialize(&n)?;
+                let program = swc_common::plugin::serialized::VersionedSerializable::new(n);
+                let mut serialized = PluginSerializedBytes::try_serialize(&program)?;
 
                 if let Some(plugins) = &mut self.plugins {
                     for p in plugins.drain(..) {
@@ -192,9 +194,9 @@ impl RustPlugins {
                                 Some(p.1),
                             )?;
 
-                        serialized_program = transform_plugin_executor
+                        serialized = transform_plugin_executor
                             .transform(
-                                &serialized_program,
+                                &serialized,
                                 self.unresolved_mark,
                                 should_enable_comments_proxy,
                             )
@@ -204,7 +206,7 @@ impl RustPlugins {
                     }
                 }
 
-                serialized_program.deserialize()
+                serialized_program.deserialize().map(|v| v.into_inner())
             },
         )
     }

crates/swc/src/plugin.rs

@@ -59,7 +59,7 @@ impl PluginSerializedBytes {
      * to implement TryFrom trait
      */
     #[tracing::instrument(level = "info", skip_all)]
-    pub fn try_serialize<W>(t: &W) -> Result<Self, Error>
+    pub fn try_serialize<W>(t: &VersionedSerializable<W>) -> Result<Self, Error>
     where
         W: rkyv::Serialize<rkyv::ser::serializers::AllocSerializer<512>>,
     {
@@ -99,14 +99,14 @@ impl PluginSerializedBytes {
     }
 
     #[tracing::instrument(level = "info", skip_all)]
-    pub fn deserialize<W>(&self) -> Result<W, Error>
+    pub fn deserialize<W>(&self) -> Result<VersionedSerializable<W>, Error>
     where
         W: rkyv::Archive,
         W::Archived: rkyv::Deserialize<W, rkyv::de::deserializers::SharedDeserializeMap>,
     {
         use anyhow::Context;
 
-        let archived = unsafe { rkyv::archived_root::<W>(&self.field[..]) };
+        let archived = unsafe { rkyv::archived_root::<VersionedSerializable<W>>(&self.field[..]) };
 
         archived
             .deserialize(&mut rkyv::de::deserializers::SharedDeserializeMap::new())
@@ -124,7 +124,7 @@ impl PluginSerializedBytes {
 pub unsafe fn deserialize_from_ptr<W>(
     raw_allocated_ptr: *const u8,
     raw_allocated_ptr_len: u32,
-) -> Result<W, Error>
+) -> Result<VersionedSerializable<W>, Error>
 where
     W: rkyv::Archive,
     W::Archived: rkyv::Deserialize<W, rkyv::de::deserializers::SharedDeserializeMap>,
@@ -135,37 +135,30 @@ where
     serialized.deserialize()
 }
 
-/// Deserialize `Fallible` struct from raw ptr. This is similar to
-/// `deserialize_from_ptr` but for the struct requires bounds to the
-/// SharedSerializeRegistry which cannot be Infallible. Internally this does
-/// not call deserialize with Infallible deserializer, use
-/// SharedDeserializeMap instead.
-#[tracing::instrument(level = "info", skip_all)]
-pub fn deserialize_from_ptr_into_fallible<W>(
-    raw_allocated_ptr: *const u8,
-    raw_allocated_ptr_len: u32,
-) -> Result<W, Error>
-where
-    W: rkyv::Archive,
-    W::Archived: rkyv::Deserialize<W, rkyv::de::deserializers::SharedDeserializeMap>,
-{
-    let serialized =
-        PluginSerializedBytes::from_raw_ptr(raw_allocated_ptr, raw_allocated_ptr_len as usize);
-
-    serialized.deserialize()
-}
-
-/*
 /// A wrapper type for the structures to be passed into plugins
 /// serializes the contained value out-of-line so that newer
 /// versions can be viewed as the older version.
 ///
-#[derive(Archive, Deserialize, Serialize)]
-pub struct VersionedSerializable<T>(#[with(AsBox)] T);
+/// First field indicate version of struct type (schema). Any consumers like
+/// swc_plugin_macro can use this to validate compatiblility before attempt to
+/// serialize.
+#[cfg_attr(
+    feature = "__plugin",
+    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
+)]
+#[repr(transparent)]
+#[cfg_attr(feature = "__plugin", archive(check_bytes))]
+#[cfg_attr(feature = "__plugin", archive_attr(repr(transparent)))]
+#[derive(Debug)]
+pub struct VersionedSerializable<T>(
+    // [NOTE]: https://github.com/rkyv/rkyv/issues/373#issuecomment-1546360897
+    //#[cfg_attr(feature = "__plugin", with(rkyv::with::AsBox))]
+    pub T,
+);
 
 impl<T> VersionedSerializable<T> {
     pub fn new(value: T) -> Self {
-        VersionedSerializable(value)
+        Self(value)
     }
 
     pub fn inner(&self) -> &T {
@@ -176,4 +169,3 @@ impl<T> VersionedSerializable<T> {
         self.0
     }
 }
- */

crates/swc_common/src/plugin/serialized.rs

@@ -181,8 +181,10 @@ impl Mark {
     pub fn is_descendant_of(mut self, ancestor: Mark) -> bool {
         // This code path executed inside of the guest memory context.
         // In here, preallocate memory for the context.
+
+        use crate::plugin::serialized::VersionedSerializable;
         let serialized = crate::plugin::serialized::PluginSerializedBytes::try_serialize(
-            &MutableMarkContext(0, 0, 0),
+            &VersionedSerializable::new(MutableMarkContext(0, 0, 0)),
         )
         .expect("Should be serializable");
         let (ptr, len) = serialized.as_ptr();
@@ -200,6 +202,7 @@ impl Mark {
                 len.try_into().expect("Should able to convert ptr length"),
             )
             .expect("Should able to deserialize")
+            .into_inner()
         };
         self = Mark::from_u32(context.0);
 
@@ -222,8 +225,10 @@ impl Mark {
     #[allow(unused_mut, unused_assignments)]
     #[cfg(all(feature = "__plugin_mode", target_arch = "wasm32"))]
     pub fn least_ancestor(mut a: Mark, mut b: Mark) -> Mark {
+        use crate::plugin::serialized::VersionedSerializable;
+
         let serialized = crate::plugin::serialized::PluginSerializedBytes::try_serialize(
-            &MutableMarkContext(0, 0, 0),
+            &VersionedSerializable::new(MutableMarkContext(0, 0, 0)),
         )
         .expect("Should be serializable");
         let (ptr, len) = serialized.as_ptr();
@@ -238,6 +243,7 @@ impl Mark {
                 len.try_into().expect("Should able to convert ptr length"),
             )
             .expect("Should able to deserialize")
+            .into_inner()
         };
         a = Mark::from_u32(context.0);
         b = Mark::from_u32(context.1);
@@ -418,7 +424,9 @@ impl SyntaxContext {
 
     #[cfg(all(feature = "__plugin_mode", target_arch = "wasm32"))]
     pub fn remove_mark(&mut self) -> Mark {
-        let context = MutableMarkContext(0, 0, 0);
+        use crate::plugin::serialized::VersionedSerializable;
+
+        let context = VersionedSerializable::new(MutableMarkContext(0, 0, 0));
         let serialized = crate::plugin::serialized::PluginSerializedBytes::try_serialize(&context)
             .expect("Should be serializable");
         let (ptr, len) = serialized.as_ptr();
@@ -433,6 +441,7 @@ impl SyntaxContext {
                 len.try_into().expect("Should able to convert ptr length"),
             )
             .expect("Should able to deserialize")
+            .into_inner()
         };
 
         *self = SyntaxContext(context.0);

crates/swc_common/src/syntax_pos/hygiene.rs

@@ -60,7 +60,7 @@ fn handle_func(func: ItemFn, ast_type: Ident) -> TokenStream {
         impl swc_core::common::errors::Emitter for PluginDiagnosticsEmitter {
             #[cfg_attr(not(target_arch = "wasm32"), allow(unused))]
             fn emit(&mut self, db: &swc_core::common::errors::DiagnosticBuilder<'_>) {
-                let diag = swc_core::common::plugin::serialized::PluginSerializedBytes::try_serialize(&*db.diagnostic)
+                let diag = swc_core::common::plugin::serialized::PluginSerializedBytes::try_serialize(&swc_core::common::plugin::serialized::VersionedSerializable::new(*db.diagnostic.clone()))
                     .expect("Should able to serialize Diagnostic");
                 let (ptr, len) = diag.as_ptr();
 
@@ -83,7 +83,7 @@ fn handle_func(func: ItemFn, ast_type: Ident) -> TokenStream {
 
         /// Internal function plugin_macro uses to create ptr to PluginError.
         fn construct_error_ptr(plugin_error: swc_core::common::plugin::serialized::PluginError) -> u32 {
-            let ret = swc_core::common::plugin::serialized::PluginSerializedBytes::try_serialize(&plugin_error).expect("Should able to serialize PluginError");
+            let ret = swc_core::common::plugin::serialized::PluginSerializedBytes::try_serialize(&swc_core::common::plugin::serialized::VersionedSerializable::new(plugin_error)).expect("Should able to serialize PluginError");
             let (ptr, len) = ret.as_ptr();
 
             send_transform_result_to_host(
@@ -107,7 +107,7 @@ fn handle_func(func: ItemFn, ast_type: Ident) -> TokenStream {
             };
 
             let serialized_result = swc_core::common::plugin::serialized::PluginSerializedBytes::try_serialize(
-                &result
+                &swc_core::common::plugin::serialized::VersionedSerializable::new(result)
             ).expect("Diagnostics should be always serializable");
 
             let (serialized_result_ptr, serialized_result_ptr_len) = serialized_result.as_ptr();
@@ -135,7 +135,7 @@ fn handle_func(func: ItemFn, ast_type: Ident) -> TokenStream {
                 let err = swc_core::common::plugin::serialized::PluginError::Deserialize("Failed to deserialize program received from host".to_string());
                 return construct_error_ptr(err);
             }
-            let program: #ast_type = program.expect("Should be a program");
+            let program: #ast_type = program.expect("Should be a program").into_inner();
 
             // Create a handler wired with plugin's diagnostic emitter, set it for global context.
             let handler = swc_core::common::errors::Handler::with_emitter(
@@ -161,7 +161,7 @@ fn handle_func(func: ItemFn, ast_type: Ident) -> TokenStream {
             };
 
             // Take original plugin fn ident, then call it with interop'ed args
-            let transformed_program = #ident(program, metadata);
+            let transformed_program = swc_core::common::plugin::serialized::VersionedSerializable::new(#ident(program, metadata));
 
             // Serialize transformed result, return back to the host.
             let serialized_result = swc_core::common::plugin::serialized::PluginSerializedBytes::try_serialize(

crates/swc_plugin_macro/src/lib.rs

@@ -52,9 +52,10 @@ impl PluginCommentsProxy {
     {
         #[cfg(target_arch = "wasm32")]
         {
-            let serialized =
-                swc_common::plugin::serialized::PluginSerializedBytes::try_serialize(&value)
-                    .expect("Should able to serialize value");
+            let serialized = swc_common::plugin::serialized::PluginSerializedBytes::try_serialize(
+                &swc_common::plugin::serialized::VersionedSerializable::new(value),
+            )
+            .expect("Should able to serialize value");
             let (serialized_comment_ptr, serialized_comment_ptr_len) = serialized.as_ptr();
             unsafe {
                 // We need to copy PluginCommentProxy's param for add_leading (Comment, or

crates/swc_plugin_proxy/src/comments/plugin_comments_proxy.rs

@@ -44,7 +44,8 @@ where
     F: FnOnce(u32) -> u32,
 {
     // Allocate AllocatedBytesPtr to get return value from the host
-    let allocated_bytes_ptr = AllocatedBytesPtr(0, 0);
+    let allocated_bytes_ptr =
+        swc_common::plugin::serialized::VersionedSerializable::new(AllocatedBytesPtr(0, 0));
     let serialized_allocated_bytes_ptr = PluginSerializedBytes::try_serialize(&allocated_bytes_ptr)
         .expect("Should able to serialize AllocatedBytesPtr");
     let (serialized_allocated_bytes_raw_ptr, serialized_allocated_bytes_raw_ptr_size) =
@@ -69,6 +70,7 @@ where
                 .expect("Should able to convert ptr length"),
         )
         .expect("Should able to deserialize AllocatedBytesPtr")
+        .into_inner()
     })
 }
 
@@ -98,5 +100,6 @@ where
             allocated_returned_value_ptr.1,
         )
         .expect("Returned value should be serializable")
+        .into_inner()
     })
 }

crates/swc_plugin_proxy/src/memory_interop/read_returned_result_from_host.rs

@@ -79,7 +79,7 @@ impl TransformPluginProgramMetadata {
         #[cfg(target_arch = "wasm32")]
         return read_returned_result_from_host(|serialized_ptr| unsafe {
             let serialized = swc_common::plugin::serialized::PluginSerializedBytes::try_serialize(
-                &key.to_string(),
+                &swc_common::plugin::serialized::VersionedSerializable::new(key.to_string()),
             )
             .expect("Should be serializable");
             let (key_ptr, key_ptr_len) = serialized.as_ptr();

crates/swc_plugin_proxy/src/metadata/transform_plugin_metadata.rs

@@ -230,9 +230,10 @@ impl SourceMapper for PluginSourceMapProxy {
                 ctxt: swc_common::SyntaxContext::empty(),
             };
 
-            let serialized =
-                swc_common::plugin::serialized::PluginSerializedBytes::try_serialize(&span)
-                    .expect("Should be serializable");
+            let serialized = swc_common::plugin::serialized::PluginSerializedBytes::try_serialize(
+                &swc_common::plugin::serialized::VersionedSerializable::new(span),
+            )
+            .expect("Should be serializable");
             let (ptr, len) = serialized.as_ptr();
 
             let ret = __merge_spans_proxy(

crates/swc_plugin_proxy/src/source_map/plugin_source_map_proxy.rs

@@ -11,7 +11,7 @@ use std::{
 
 use criterion::{black_box, criterion_group, criterion_main, Bencher, Criterion};
 #[cfg(feature = "__rkyv")]
-use swc_common::plugin::serialized::PluginSerializedBytes;
+use swc_common::plugin::serialized::{PluginSerializedBytes, VersionedSerializable};
 use swc_common::{
     collections::AHashMap, plugin::metadata::TransformPluginMetadataContext, FileName,
     FilePathMapping, Globals, Mark, SourceMap, GLOBALS,
@@ -62,6 +62,7 @@ fn bench_transform(b: &mut Bencher, plugin_dir: &Path) {
             )
             .unwrap();
 
+            let program = VersionedSerializable::new(program);
             let program_ser = PluginSerializedBytes::try_serialize(&program).unwrap();
 
             let mut transform_plugin_executor =
@@ -82,7 +83,8 @@ fn bench_transform(b: &mut Bencher, plugin_dir: &Path) {
                 )
                 .unwrap();
 
-            let experimental_metadata: AHashMap<String, String> = AHashMap::default();
+            let experimental_metadata: VersionedSerializable<AHashMap<String, String>> =
+                VersionedSerializable::new(AHashMap::default());
             let _experimental_metadata =
                 PluginSerializedBytes::try_serialize(&experimental_metadata)
                     .expect("Should be a hashmap");

crates/swc_plugin_runner/benches/ecma_invoke.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use parking_lot::Mutex;
 use swc_common::{
     comments::{Comments, SingleThreadedComments},
-    plugin::serialized::PluginSerializedBytes,
+    plugin::serialized::{PluginSerializedBytes, VersionedSerializable},
     BytePos,
 };
 use swc_plugin_proxy::COMMENTS;
@@ -142,7 +142,8 @@ pub fn add_leading_comment_proxy(env: FunctionEnvMut<CommentHostEnvironment>, by
             byte_pos,
             serialized
                 .deserialize()
-                .expect("Should be able to deserialize"),
+                .expect("Should be able to deserialize")
+                .into_inner(),
         );
     });
 }
@@ -154,7 +155,8 @@ pub fn add_leading_comments_proxy(env: FunctionEnvMut<CommentHostEnvironment>, b
             byte_pos,
             serialized
                 .deserialize()
-                .expect("Should be able to deserialize"),
+                .expect("Should be able to deserialize")
+                .into_inner(),
         );
     });
 }
@@ -191,9 +193,10 @@ pub fn take_leading_comments_proxy(
         |comments| {
             let leading_comments = comments.take_leading(BytePos(byte_pos));
             if let Some(leading_comments) = leading_comments {
-                let serialized_leading_comments_vec_bytes =
-                    PluginSerializedBytes::try_serialize(&leading_comments)
-                        .expect("Should be serializable");
+                let serialized_leading_comments_vec_bytes = PluginSerializedBytes::try_serialize(
+                    &VersionedSerializable::new(leading_comments),
+                )
+                .expect("Should be serializable");
 
                 allocate_return_values_into_guest(
                     memory,
@@ -236,9 +239,10 @@ pub fn get_leading_comments_proxy(
         |comments| {
             let leading_comments = comments.get_leading(BytePos(byte_pos));
             if let Some(leading_comments) = leading_comments {
-                let serialized_leading_comments_vec_bytes =
-                    PluginSerializedBytes::try_serialize(&leading_comments)
-                        .expect("Should be serializable");
+                let serialized_leading_comments_vec_bytes = PluginSerializedBytes::try_serialize(
+                    &VersionedSerializable::new(leading_comments),
+                )
+                .expect("Should be serializable");
 
                 allocate_return_values_into_guest(
                     memory,
@@ -263,7 +267,8 @@ pub fn add_trailing_comment_proxy(env: FunctionEnvMut<CommentHostEnvironment>, b
             byte_pos,
             serialized
                 .deserialize()
-                .expect("Should be able to deserialize"),
+                .expect("Should be able to deserialize")
+                .into_inner(),
         );
     });
 }
@@ -275,7 +280,8 @@ pub fn add_trailing_comments_proxy(env: FunctionEnvMut<CommentHostEnvironment>,
             byte_pos,
             serialized
                 .deserialize()
-                .expect("Should be able to deserialize"),
+                .expect("Should be able to deserialize")
+                .into_inner(),
         );
     });
 }
@@ -315,9 +321,10 @@ pub fn take_trailing_comments_proxy(
         |comments| {
             let trailing_comments = comments.take_trailing(BytePos(byte_pos));
             if let Some(leading_comments) = trailing_comments {
-                let serialized_leading_comments_vec_bytes =
-                    PluginSerializedBytes::try_serialize(&leading_comments)
-                        .expect("Should be serializable");
+                let serialized_leading_comments_vec_bytes = PluginSerializedBytes::try_serialize(
+                    &VersionedSerializable::new(leading_comments),
+                )
+                .expect("Should be serializable");
 
                 allocate_return_values_into_guest(
                     memory,
@@ -355,9 +362,10 @@ pub fn get_trailing_comments_proxy(
         |comments| {
             let trailing_comments = comments.get_trailing(BytePos(byte_pos));
             if let Some(leading_comments) = trailing_comments {
-                let serialized_leading_comments_vec_bytes =
-                    PluginSerializedBytes::try_serialize(&leading_comments)
-                        .expect("Should be serializable");
+                let serialized_leading_comments_vec_bytes = PluginSerializedBytes::try_serialize(
+                    &VersionedSerializable::new(leading_comments),
+                )
+                .expect("Should be serializable");
 
                 allocate_return_values_into_guest(
                     memory,

crates/swc_plugin_runner/src/imported_fn/comments.rs

@@ -26,8 +26,10 @@ pub fn emit_diagnostics(
             let diagnostic = PluginSerializedBytes::deserialize::<Diagnostic>(&serialized)
                 .expect("Should able to be deserialized into diagnostic");
 
-            let mut builder =
-                swc_common::errors::DiagnosticBuilder::new_diagnostic(handler, diagnostic);
+            let mut builder = swc_common::errors::DiagnosticBuilder::new_diagnostic(
+                handler,
+                diagnostic.into_inner(),
+            );
             builder.emit();
         })
     }

crates/swc_plugin_runner/src/imported_fn/handler.rs

@@ -1,5 +1,7 @@
 use swc_common::{
-    hygiene::MutableMarkContext, plugin::serialized::PluginSerializedBytes, Mark, SyntaxContext,
+    hygiene::MutableMarkContext,
+    plugin::serialized::{PluginSerializedBytes, VersionedSerializable},
+    Mark, SyntaxContext,
 };
 use wasmer::{AsStoreMut, FunctionEnvMut};
 
@@ -46,7 +48,11 @@ pub fn mark_is_descendant_of_proxy(
 
     let return_value = self_mark.is_descendant_of(ancestor);
 
-    let context = MutableMarkContext(self_mark.as_u32(), 0, return_value as u32);
+    let context = VersionedSerializable::new(MutableMarkContext(
+        self_mark.as_u32(),
+        0,
+        return_value as u32,
+    ));
     let serialized_bytes =
         PluginSerializedBytes::try_serialize(&context).expect("Should be serializable");
 
@@ -75,7 +81,8 @@ pub fn mark_least_ancestor_proxy(
 
     let return_value = Mark::least_ancestor(a, b).as_u32();
 
-    let context = MutableMarkContext(a.as_u32(), b.as_u32(), return_value);
+    let context =
+        VersionedSerializable::new(MutableMarkContext(a.as_u32(), b.as_u32(), return_value));
     let serialized_bytes =
         PluginSerializedBytes::try_serialize(&context).expect("Should be serializable");
 
@@ -109,7 +116,11 @@ pub fn syntax_context_remove_mark_proxy(
 
     let return_value = self_mark.remove_mark();
 
-    let context = MutableMarkContext(self_mark.as_u32(), 0, return_value.as_u32());
+    let context = VersionedSerializable::new(MutableMarkContext(
+        self_mark.as_u32(),
+        0,
+        return_value.as_u32(),
+    ));
     let serialized_bytes =
         PluginSerializedBytes::try_serialize(&context).expect("Should be serializable");
 

crates/swc_plugin_runner/src/imported_fn/hygiene.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use parking_lot::Mutex;
 use swc_common::plugin::{
     metadata::{TransformPluginMetadataContext, TransformPluginMetadataContextKind},
-    serialized::PluginSerializedBytes,
+    serialized::{PluginSerializedBytes, VersionedSerializable},
 };
 use wasmer::{AsStoreMut, FunctionEnvMut, Memory, TypedFunction};
 
@@ -77,7 +77,8 @@ pub fn get_transform_plugin_config(
         let config = serde_json::to_string(config_value).ok();
         if let Some(config) = config {
             let serialized =
-                PluginSerializedBytes::try_serialize(&config).expect("Should be serializable");
+                PluginSerializedBytes::try_serialize(&VersionedSerializable::new(config))
+                    .expect("Should be serializable");
 
             allocate_return_values_into_guest(
                 memory,
@@ -109,10 +110,11 @@ pub fn get_transform_context(
         .as_ref()
         .expect("Alloc guest memory fn should be available, check initialization");
 
-    let value = env
-        .data()
-        .metadata_context
-        .get(&TransformPluginMetadataContextKind::from(key));
+    let value = VersionedSerializable::new(
+        env.data()
+            .metadata_context
+            .get(&TransformPluginMetadataContextKind::from(key)),
+    );
 
     let serialized = PluginSerializedBytes::try_serialize(&value).expect("Should be serializable");
 
@@ -145,7 +147,8 @@ pub fn get_experimental_transform_context(
     let context_key_buffer = env.data().mutable_context_key_buffer.lock().clone();
     let key: String = PluginSerializedBytes::from_slice(&context_key_buffer[..])
         .deserialize()
-        .expect("Should able to deserialize");
+        .expect("Should able to deserialize")
+        .into_inner();
 
     let value = env
         .data()
@@ -155,8 +158,8 @@ pub fn get_experimental_transform_context(
         .map(|v| v.to_string());
 
     if let Some(value) = value {
-        let serialized =
-            PluginSerializedBytes::try_serialize(&value).expect("Should be serializable");
+        let serialized = PluginSerializedBytes::try_serialize(&VersionedSerializable::new(value))
+            .expect("Should be serializable");
 
         allocate_return_values_into_guest(
             memory,
@@ -187,7 +190,8 @@ pub fn get_raw_experiemtal_transform_context(
         .as_ref()
         .expect("Alloc guest memory fn should be available, check initialization");
 
-    let experimental_context = env.data().metadata_context.experimental.clone();
+    let experimental_context =
+        VersionedSerializable::new(env.data().metadata_context.experimental.clone());
     let serialized_experimental_context_bytes =
         PluginSerializedBytes::try_serialize(&experimental_context)
             .expect("Should be serializable");

crates/swc_plugin_runner/src/imported_fn/metadata_context.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use parking_lot::Mutex;
 use swc_common::{
-    plugin::serialized::PluginSerializedBytes,
+    plugin::serialized::{PluginSerializedBytes, VersionedSerializable},
     source_map::{PartialFileLines, PartialLoc},
     BytePos, SourceMap, SourceMapper, Span, SyntaxContext,
 };
@@ -58,7 +58,7 @@ pub fn lookup_char_pos_proxy(
         .expect("Alloc guest memory fn should be available, check initialization");
 
     let original_loc = (env.data().source_map.lock()).lookup_char_pos(BytePos(byte_pos));
-    let ret = PartialLoc {
+    let ret = VersionedSerializable::new(PartialLoc {
         source_file: if should_include_source_file == 0 {
             None
         } else {
@@ -67,7 +67,7 @@ pub fn lookup_char_pos_proxy(
         line: original_loc.line,
         col: original_loc.col.0,
         col_display: original_loc.col_display,
-    };
+    });
 
     let serialized_loc_bytes =
         PluginSerializedBytes::try_serialize(&ret).expect("Should be serializable");
@@ -118,6 +118,7 @@ pub fn merge_spans_proxy(
 
     let ret = (env.data().source_map.lock()).merge_spans(sp_lhs, sp_rhs);
     if let Some(span) = ret {
+        let span = VersionedSerializable::new(span);
         let serialized_bytes =
             PluginSerializedBytes::try_serialize(&span).expect("Should be serializable");
         write_into_memory_view(
@@ -169,7 +170,8 @@ pub fn span_to_lines_proxy(
         });
 
     let serialized_loc_bytes =
-        PluginSerializedBytes::try_serialize(&ret).expect("Should be serializable");
+        PluginSerializedBytes::try_serialize(&VersionedSerializable::new(ret))
+            .expect("Should be serializable");
 
     allocate_return_values_into_guest(
         memory,
@@ -201,7 +203,8 @@ pub fn lookup_byte_offset_proxy(
     let ret = (env.data().source_map.lock()).lookup_byte_offset(byte_pos);
 
     let serialized_loc_bytes =
-        PluginSerializedBytes::try_serialize(&ret).expect("Should be serializable");
+        PluginSerializedBytes::try_serialize(&VersionedSerializable::new(ret))
+            .expect("Should be serializable");
 
     allocate_return_values_into_guest(
         memory,
@@ -238,7 +241,8 @@ pub fn span_to_string_proxy(
     };
     let ret = (env.data().source_map.lock()).span_to_string(span);
     let serialized_loc_bytes =
-        PluginSerializedBytes::try_serialize(&ret).expect("Should be serializable");
+        PluginSerializedBytes::try_serialize(&VersionedSerializable::new(ret))
+            .expect("Should be serializable");
 
     allocate_return_values_into_guest(
         memory,
@@ -275,7 +279,8 @@ pub fn span_to_filename_proxy(
     };
     let ret = (env.data().source_map.lock()).span_to_filename(span);
     let serialized_loc_bytes =
-        PluginSerializedBytes::try_serialize(&ret).expect("Should be serializable");
+        PluginSerializedBytes::try_serialize(&VersionedSerializable::new(ret))
+            .expect("Should be serializable");
 
     allocate_return_values_into_guest(
         memory,
@@ -312,7 +317,8 @@ pub fn span_to_source_proxy(
     };
     let ret = (*env.data().source_map.lock()).span_to_snippet(span);
     let serialized_loc_bytes =
-        PluginSerializedBytes::try_serialize(&ret).expect("Should be serializable");
+        PluginSerializedBytes::try_serialize(&VersionedSerializable::new(ret))
+            .expect("Should be serializable");
 
     allocate_return_values_into_guest(
         memory,

crates/swc_plugin_runner/src/imported_fn/source_map.rs

@@ -175,7 +175,8 @@ pub fn load_plugin(
 
             let diag_result: PluginCorePkgDiagnostics =
                 PluginSerializedBytes::from_slice(&(&(*diagnostics_buffer.lock()))[..])
-                    .deserialize()?;
+                    .deserialize()?
+                    .into_inner();
 
             Ok((instance, transform_result, diag_result, wasi_env))
         }

crates/swc_plugin_runner/src/load_plugin.rs

@@ -1,4 +1,4 @@
-use swc_common::plugin::serialized::PluginSerializedBytes;
+use swc_common::plugin::serialized::{PluginSerializedBytes, VersionedSerializable};
 use swc_plugin_proxy::AllocatedBytesPtr;
 use wasmer::{Memory, MemoryView, StoreMut, TypedFunction, WasmPtr};
 
@@ -78,7 +78,8 @@ pub fn allocate_return_values_into_guest(
     let (allocated_ptr, allocated_ptr_len) =
         write_into_memory_view(memory, store, serialized_bytes, |_, _| guest_memory_ptr);
 
-    let allocated_bytes = AllocatedBytesPtr(allocated_ptr, allocated_ptr_len);
+    let allocated_bytes =
+        VersionedSerializable::new(AllocatedBytesPtr(allocated_ptr, allocated_ptr_len));
     // Retuning (allocated_ptr, len) into caller (plugin)
     let comment_ptr_serialized =
         PluginSerializedBytes::try_serialize(&allocated_bytes).expect("Should be serializable");

crates/swc_plugin_runner/src/memory_interop.rs

@@ -153,7 +153,7 @@ impl TransformExecutor {
         if returned_ptr_result == 0 {
             Ok(ret)
         } else {
-            let err: PluginError = ret.deserialize()?;
+            let err: PluginError = ret.deserialize()?.into_inner();
             match err {
                 PluginError::SizeInteropFailure(msg) => Err(anyhow!(
                     "Failed to convert pointer size to calculate: {}",

crates/swc_plugin_runner/src/transform_executor.rs

@@ -73,7 +73,10 @@ fn invoke(input: PathBuf) -> Result<(), Error> {
         let parsed: Stylesheet =
             swc_css_parser::parse_file(&fm, Default::default(), &mut vec![]).unwrap();
 
-        let program = PluginSerializedBytes::try_serialize(&parsed).expect("Should serializable");
+        let program = PluginSerializedBytes::try_serialize(
+            &swc_common::plugin::serialized::VersionedSerializable::new(parsed.clone()),
+        )
+        .expect("Should serializable");
         let experimental_metadata: AHashMap<String, String> = [
             (
                 "TestExperimental".to_string(),
@@ -105,7 +108,8 @@ fn invoke(input: PathBuf) -> Result<(), Error> {
 
         let program: Stylesheet = program_bytes
             .deserialize()
-            .expect("Should able to deserialize");
+            .expect("Should able to deserialize")
+            .into_inner();
 
         assert_eq!(parsed, program);
 
@@ -120,8 +124,10 @@ fn invoke(input: PathBuf) -> Result<(), Error> {
         let parsed: Stylesheet =
             swc_css_parser::parse_file(&fm, Default::default(), &mut vec![]).unwrap();
 
-        let mut serialized_program =
-            PluginSerializedBytes::try_serialize(&parsed).expect("Should serializable");
+        let mut serialized_program = PluginSerializedBytes::try_serialize(
+            &swc_common::plugin::serialized::VersionedSerializable::new(parsed.clone()),
+        )
+        .expect("Should serializable");
 
         let experimental_metadata: AHashMap<String, String> = [
             (
@@ -170,7 +176,8 @@ fn invoke(input: PathBuf) -> Result<(), Error> {
 
         let program: Stylesheet = serialized_program
             .deserialize()
-            .expect("Should able to deserialize");
+            .expect("Should able to deserialize")
+            .into_inner();
 
         assert_eq!(parsed, program);
 

crates/swc_plugin_runner/tests/css_rkyv.rs

@@ -74,6 +74,8 @@ impl Visit for TestVisitor {
 #[cfg(feature = "__rkyv")]
 #[test]
 fn internal() -> Result<(), Error> {
+    use swc_common::plugin::serialized::VersionedSerializable;
+
     let path = build_plugin(
         &PathBuf::from(env::var("CARGO_MANIFEST_DIR")?)
             .join("tests")
@@ -94,7 +96,8 @@ fn internal() -> Result<(), Error> {
         )
         .unwrap();
 
-        let program = PluginSerializedBytes::try_serialize(&program).expect("Should serializable");
+        let program = PluginSerializedBytes::try_serialize(&VersionedSerializable::new(program))
+            .expect("Should serializable");
         let experimental_metadata: AHashMap<String, String> = [
             (
                 "TestExperimental".to_string(),
@@ -130,7 +133,8 @@ fn internal() -> Result<(), Error> {
 
         let program: Program = program_bytes
             .deserialize()
-            .expect("Should able to deserialize");
+            .expect("Should able to deserialize")
+            .into_inner();
         let mut visitor = TestVisitor {
             plugin_transform_found: false,
         };
@@ -156,7 +160,8 @@ fn internal() -> Result<(), Error> {
         )
         .unwrap();
 
-        let program = PluginSerializedBytes::try_serialize(&program).expect("Should serializable");
+        let program = PluginSerializedBytes::try_serialize(&VersionedSerializable::new(program))
+            .expect("Should serializable");
         let experimental_metadata: AHashMap<String, String> = [
             (
                 "TestExperimental".to_string(),
@@ -207,7 +212,8 @@ fn internal() -> Result<(), Error> {
         .unwrap();
 
         let mut serialized_program =
-            PluginSerializedBytes::try_serialize(&program).expect("Should serializable");
+            PluginSerializedBytes::try_serialize(&VersionedSerializable::new(program))
+                .expect("Should serializable");
         let cache: Lazy<PluginModuleCache> = Lazy::new(PluginModuleCache::new);
 
         let experimental_metadata: AHashMap<String, String> = [
@@ -257,7 +263,8 @@ fn internal() -> Result<(), Error> {
 
         let program: Program = serialized_program
             .deserialize()
-            .expect("Should able to deserialize");
+            .expect("Should able to deserialize")
+            .into_inner();
         let mut visitor = TestVisitor {
             plugin_transform_found: false,
         };

crates/swc_plugin_runner/tests/ecma_integration.rs

@@ -83,7 +83,10 @@ fn internal(input: PathBuf) -> Result<(), Error> {
         )
         .unwrap();
 
-        let program = PluginSerializedBytes::try_serialize(&parsed).expect("Should serializable");
+        let program = PluginSerializedBytes::try_serialize(
+            &swc_common::plugin::serialized::VersionedSerializable::new(parsed.clone()),
+        )
+        .expect("Should serializable");
         let experimental_metadata: AHashMap<String, String> = [
             (
                 "TestExperimental".to_string(),
@@ -117,7 +120,8 @@ fn internal(input: PathBuf) -> Result<(), Error> {
 
         let program: Program = program_bytes
             .deserialize()
-            .expect("Should able to deserialize");
+            .expect("Should able to deserialize")
+            .into_inner();
 
         assert_eq!(parsed, program);
 
@@ -138,8 +142,10 @@ fn internal(input: PathBuf) -> Result<(), Error> {
         )
         .unwrap();
 
-        let mut serialized_program =
-            PluginSerializedBytes::try_serialize(&parsed).expect("Should serializable");
+        let mut serialized_program = PluginSerializedBytes::try_serialize(
+            &swc_common::plugin::serialized::VersionedSerializable::new(parsed.clone()),
+        )
+        .expect("Should serializable");
 
         let experimental_metadata: AHashMap<String, String> = [
             (
@@ -188,7 +194,8 @@ fn internal(input: PathBuf) -> Result<(), Error> {
 
         let program: Program = serialized_program
             .deserialize()
-            .expect("Should able to deserialize");
+            .expect("Should able to deserialize")
+            .into_inner();
 
         assert_eq!(parsed, program);
 

crates/swc_plugin_runner/tests/ecma_rkyv.rs

@@ -73,6 +73,8 @@ impl Visit for TestVisitor {
 #[cfg(feature = "__rkyv")]
 #[test]
 fn issue_6404() -> Result<(), Error> {
+    use swc_common::plugin::serialized::VersionedSerializable;
+
     let plugin_path = build_plugin(
         &PathBuf::from(env::var("CARGO_MANIFEST_DIR")?)
             .join("tests")
@@ -98,7 +100,8 @@ fn issue_6404() -> Result<(), Error> {
         )
         .unwrap();
 
-        let program = PluginSerializedBytes::try_serialize(&program).expect("Should serializable");
+        let program = PluginSerializedBytes::try_serialize(&VersionedSerializable::new(program))
+            .expect("Should serializable");
         let experimental_metadata: AHashMap<String, String> = [
             (
                 "TestExperimental".to_string(),
@@ -134,7 +137,8 @@ fn issue_6404() -> Result<(), Error> {
 
         let _: Program = program_bytes
             .deserialize()
-            .expect("Should able to deserialize");
+            .expect("Should able to deserialize")
+            .into_inner();
 
         Ok(())
     })

crates/swc_plugin_runner/tests/issues.rs

@@ -93,7 +93,7 @@
         "@napi-rs/cli": "^2.14.1",
         "@swc/core": "=1.2.220",
         "@swc/helpers": "^0.5.0",
-        "@swc/plugin-jest": "1.5.59",
+        "@swc/plugin-jest": "latest",
         "@taplo/cli": "^0.3.2",
         "@types/jest": "^28.1.4",
         "@types/node": "^14.14.41",

package.json

@@ -2465,7 +2465,7 @@ __metadata:
     "@swc/core-win32-ia32-msvc": 1.2.146
     "@swc/core-win32-x64-msvc": 1.2.146
     "@swc/helpers": ^0.5.0
-    "@swc/plugin-jest": 1.5.59
+    "@swc/plugin-jest": latest
     "@taplo/cli": ^0.3.2
     "@types/jest": ^28.1.4
     "@types/node": ^14.14.41
@@ -2541,10 +2541,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@swc/plugin-jest@npm:1.5.59":
-  version: 1.5.59
-  resolution: "@swc/plugin-jest@npm:1.5.59"
-  checksum: cc94723c12a6c9122a1ee3367fc55623858001435e3efaac009b8c0e1a125f97a9ac0ec773eaeb20e65a6b877204f4ea865f5fa70af1820d1ca869203f6e7561
+"@swc/plugin-jest@npm:latest":
+  version: 1.5.62
+  resolution: "@swc/plugin-jest@npm:1.5.62"
+  checksum: 722a44b0c83ab89d355781bebb987f200e503c960733c62fae5f91b6bd717b25330819d93507df8cf87695d71f318f83e566f102aec9c23f41794498e902b817
   languageName: node
   linkType: hard