refactor(plugin): Refactor transform executor (swc-project#5147)

kwonoj · GiveMe-A-Name · commit b484e61180d4 · 2022-07-23T10:48:36.000+08:00
diff --git a/crates/swc/src/plugin.rs b/crates/swc/src/plugin.rs
@@ -95,8 +95,10 @@ impl RustPlugins {
                 inner: self.comments.clone(),
             },
             || {
+                let span = tracing::span!(tracing::Level::INFO, "serialize_program").entered();
                 let program = VersionedSerializable::new(n);
-                let mut serialized = PluginSerializedBytes::try_serialize(&program)?;
+                let mut serialized_program = PluginSerializedBytes::try_serialize(&program)?;
+                drop(span);
 
                 // Run plugin transformation against current program.
                 // We do not serialize / deserialize between each plugin execution but
@@ -106,65 +108,77 @@ impl RustPlugins {
                 // transform.
                 if let Some(plugins) = &self.plugins {
                     for p in plugins {
+                        let resolved_path = self
+                            .resolver
+                            .as_ref()
+                            .expect("filesystem_cache should provide resolver")
+                            .resolve(&FileName::Real(PathBuf::from(&p.0)), &p.0)?;
+
+                        let path = if let FileName::Real(value) = resolved_path {
+                            Arc::new(value)
+                        } else {
+                            anyhow::bail!("Failed to resolve plugin path: {:?}", resolved_path);
+                        };
+
+                        let mut transform_plugin_executor =
+                            swc_plugin_runner::create_plugin_transform_executor(
+                                &path,
+                                &swc_plugin_runner::cache::PLUGIN_MODULE_CACHE,
+                                &self.source_map,
+                            )?;
+
                         let span = tracing::span!(
                             tracing::Level::INFO,
                             "serialize_context",
                             plugin_module = p.0.as_str()
                         );
                         let context_span_guard = span.enter();
 
-                        let config_json = serde_json::to_string(&p.1)
+                        let serialized_config_json = serde_json::to_string(&p.1)
                             .context("Failed to serialize plugin config as json")
                             .and_then(|value| {
                                 PluginSerializedBytes::try_serialize(&VersionedSerializable::new(
                                     value,
                                 ))
                             })?;
 
-                        let context_json = serde_json::to_string(&self.plugin_context)
+                        let serialized_context_json = serde_json::to_string(&self.plugin_context)
                             .context("Failed to serialize plugin context as json")
                             .and_then(|value| {
                                 PluginSerializedBytes::try_serialize(&VersionedSerializable::new(
                                     value,
                                 ))
                             })?;
-
-                        let resolved_path = self
-                            .resolver
-                            .as_ref()
-                            .expect("filesystem_cache should provide resolver")
-                            .resolve(&FileName::Real(PathBuf::from(&p.0)), &p.0)?;
-
-                        let path = if let FileName::Real(value) = resolved_path {
-                            Arc::new(value)
-                        } else {
-                            anyhow::bail!("Failed to resolve plugin path: {:?}", resolved_path);
-                        };
                         drop(context_span_guard);
 
                         let span = tracing::span!(
                             tracing::Level::INFO,
                             "execute_plugin_runner",
                             plugin_module = p.0.as_str()
-                        );
-                        let transform_span_guard = span.enter();
-                        serialized = swc_plugin_runner::apply_transform_plugin(
-                            &p.0,
-                            &path,
-                            &swc_plugin_runner::cache::PLUGIN_MODULE_CACHE,
-                            serialized,
-                            config_json,
-                            context_json,
-                            should_enable_comments_proxy,
-                            &self.source_map,
-                        )?;
-                        drop(transform_span_guard);
+                        )
+                        .entered();
+
+                        serialized_program = transform_plugin_executor
+                            .transform(
+                                &serialized_program,
+                                &serialized_config_json,
+                                &serialized_context_json,
+                                should_enable_comments_proxy,
+                            )
+                            .with_context(|| {
+                                format!(
+                                    "failed to invoke `{}` as js transform plugin at {}",
+                                    &p.0,
+                                    path.display()
+                                )
+                            })?;
+                        drop(span);
                     }
                 }
 
                 // Plugin transformation is done. Deserialize transformed bytes back
                 // into Program
-                serialized.deserialize().map(|v| v.into_inner())
+                serialized_program.deserialize().map(|v| v.into_inner())
             },
         )
     }
@@ -188,40 +202,47 @@ impl RustPlugins {
             },
             || {
                 let program = VersionedSerializable::new(n);
-                let mut serialized = PluginSerializedBytes::try_serialize(&program)?;
+                let mut serialized_program = PluginSerializedBytes::try_serialize(&program)?;
 
                 if let Some(plugins) = &self.plugins {
                     for p in plugins {
-                        let config_json = serde_json::to_string(&p.1)
+                        let serialized_config_json = serde_json::to_string(&p.1)
                             .context("Failed to serialize plugin config as json")
                             .and_then(|value| {
                                 PluginSerializedBytes::try_serialize(&VersionedSerializable::new(
                                     value,
                                 ))
                             })?;
 
-                        let context_json = serde_json::to_string(&self.plugin_context)
+                        let serialized_context_json = serde_json::to_string(&self.plugin_context)
                             .context("Failed to serialize plugin context as json")
                             .and_then(|value| {
                                 PluginSerializedBytes::try_serialize(&VersionedSerializable::new(
                                     value,
                                 ))
                             })?;
 
-                        serialized = swc_plugin_runner::apply_transform_plugin(
-                            &p.0,
-                            &PathBuf::from(&p.0),
-                            &swc_plugin_runner::cache::PLUGIN_MODULE_CACHE,
-                            serialized,
-                            config_json,
-                            context_json,
-                            should_enable_comments_proxy,
-                            &self.source_map,
-                        )?;
+                        let mut transform_plugin_executor =
+                            swc_plugin_runner::create_plugin_transform_executor(
+                                &PathBuf::from(&p.0),
+                                &swc_plugin_runner::cache::PLUGIN_MODULE_CACHE,
+                                &self.source_map,
+                            )?;
+
+                        serialized_program = transform_plugin_executor
+                            .transform(
+                                &serialized_program,
+                                &serialized_config_json,
+                                &serialized_context_json,
+                                should_enable_comments_proxy,
+                            )
+                            .with_context(|| {
+                                format!("failed to invoke `{}` as js transform plugin", &p.0)
+                            })?;
                     }
                 }
 
-                serialized.deserialize().map(|v| v.into_inner())
+                serialized_program.deserialize().map(|v| v.into_inner())
             },
         )
     }
diff --git a/crates/swc_cli/src/commands/plugin.rs b/crates/swc_cli/src/commands/plugin.rs
@@ -228,7 +228,7 @@ impl VisitMut for TransformVisitor {
 /// as returning ptr back to host.
 ///
 /// It is possible to opt out from macro by writing transform fn manually via
-/// `__plugin_process_impl(
+/// `__transform_plugin_process_impl(
 ///     ast_ptr: *const u8,
 ///     ast_ptr_len: i32,
 ///     config_str_ptr: *const u8,
diff --git a/crates/swc_plugin_macro/src/lib.rs b/crates/swc_plugin_macro/src/lib.rs
@@ -19,7 +19,8 @@ pub fn plugin_transform(
 
 fn handle_func(func: ItemFn) -> TokenStream {
     let ident = func.sig.ident.clone();
-    let process_impl_ident = Ident::new("__plugin_process_impl", Span::call_site());
+    let transform_process_impl_ident =
+        Ident::new("__transform_plugin_process_impl", Span::call_site());
 
     let ret = quote! {
         #func
@@ -59,7 +60,7 @@ fn handle_func(func: ItemFn) -> TokenStream {
         // There are some cases error won't be wrapped up however - for example, we expect
         // serialization of PluginError itself should succeed.
         #[no_mangle]
-        pub fn #process_impl_ident(ast_ptr: *const u8, ast_ptr_len: i32, config_str_ptr: *const u8, config_str_ptr_len: i32, context_str_ptr: *const u8, context_str_ptr_len: i32, should_enable_comments_proxy: i32) -> i32 {
+        pub fn #transform_process_impl_ident(ast_ptr: *const u8, ast_ptr_len: i32, config_str_ptr: *const u8, config_str_ptr_len: i32, context_str_ptr: *const u8, context_str_ptr_len: i32, should_enable_comments_proxy: i32) -> i32 {
             // Reconstruct `Program` & config string from serialized program
             // Host (SWC) should allocate memory, copy bytes and pass ptr to plugin.
             let program = unsafe { swc_plugin::deserialize_from_ptr(ast_ptr, ast_ptr_len).map(|v| v.into_inner()) };
diff --git a/crates/swc_plugin_proxy/src/comments/host_comments_storage.rs b/crates/swc_plugin_proxy/src/comments/host_comments_storage.rs
@@ -5,8 +5,8 @@
 /// specifically `SingleThreadedComments`. It doesn't support thread-safety
 /// which does not allow to be passed into wasmerEnv (HostEnvironment). A scoped
 /// tls holds inner comments as global, per each transform execution. Refer
-/// `swc::RustPlugins::apply_transform_plugin` for the responsibility to manage
-/// actual data.
+/// `swc_plugin::transform_execytor::TransformExecutor::transform` for the
+/// responsibility to manage actual data.
 ///
 /// Should never attempt to use this other than plugin_runner.
 // TODO: This storage does not support mutable yet
diff --git a/crates/swc_plugin_runner/benches/invoke.rs b/crates/swc_plugin_runner/benches/invoke.rs
@@ -62,24 +62,32 @@ fn bench_transform(b: &mut Bencher, plugin_dir: &Path) {
         let program = VersionedSerializable::new(program);
         let program_ser = PluginSerializedBytes::try_serialize(&program).unwrap();
 
-        let res = swc_plugin_runner::apply_transform_plugin(
-            "test",
+        let mut transform_plugin_executor = swc_plugin_runner::create_plugin_transform_executor(
             &plugin_dir
                 .join("target")
                 .join("wasm32-unknown-unknown")
                 .join("release")
                 .join("swc_internal_plugin.wasm"),
-            &cache,
-            program_ser,
-            PluginSerializedBytes::try_serialize(&VersionedSerializable::new(String::from("{}")))
-                .unwrap(),
-            PluginSerializedBytes::try_serialize(&VersionedSerializable::new(String::from("{}")))
-                .unwrap(),
-            true,
+            &swc_plugin_runner::cache::PLUGIN_MODULE_CACHE,
             &cm,
         )
         .unwrap();
 
+        let res = transform_plugin_executor
+            .transform(
+                &program_ser,
+                &PluginSerializedBytes::try_serialize(&VersionedSerializable::new(String::from(
+                    "{}",
+                )))
+                .unwrap(),
+                &PluginSerializedBytes::try_serialize(&VersionedSerializable::new(String::from(
+                    "{}",
+                )))
+                .unwrap(),
+                true,
+            )
+            .unwrap();
+
         let _ = black_box(res);
     })
 }
diff --git a/crates/swc_plugin_runner/src/lib.rs b/crates/swc_plugin_runner/src/lib.rs
@@ -1,8 +1,8 @@
 use std::{path::Path, sync::Arc};
 
-use anyhow::{Context, Error};
+use anyhow::Error;
 use once_cell::sync::Lazy;
-use swc_common::{plugin::PluginSerializedBytes, SourceMap};
+use swc_common::SourceMap;
 use transform_executor::TransformExecutor;
 
 pub mod cache;
@@ -12,33 +12,18 @@ mod load_plugin;
 mod memory_interop;
 mod transform_executor;
 
-// entrypoint fn swc calls to perform its transform via plugin.
-#[allow(clippy::too_many_arguments)]
-pub fn apply_transform_plugin(
-    plugin_name: &str,
+/**
+ * Attempt to create a executor to run plugin binaries.
+ * Internally this will try to load binary from given cache which can fail,
+ * returns error in that case.
+ *
+ * Note you CANNOT reuse executor once trasform has been executed: executor
+ * is stateful.
+ */
+pub fn create_plugin_transform_executor(
     path: &Path,
     cache: &Lazy<cache::PluginModuleCache>,
-    program: PluginSerializedBytes,
-    config_json: PluginSerializedBytes,
-    context_json: PluginSerializedBytes,
-    should_enable_comments_proxy: bool,
     source_map: &Arc<SourceMap>,
-) -> Result<PluginSerializedBytes, Error> {
-    (|| -> Result<_, Error> {
-        let mut transform_tracker = TransformExecutor::new(path, cache, source_map)?;
-        let should_enable_comments_proxy = if should_enable_comments_proxy { 1 } else { 0 };
-        transform_tracker.transform(
-            &program,
-            &config_json,
-            &context_json,
-            should_enable_comments_proxy,
-        )
-    })()
-    .with_context(|| {
-        format!(
-            "failed to invoke `{}` as js transform plugin at {}",
-            plugin_name,
-            path.display()
-        )
-    })
+) -> Result<TransformExecutor, Error> {
+    TransformExecutor::new(path, cache, source_map)
 }
diff --git a/crates/swc_plugin_runner/src/transform_executor.rs b/crates/swc_plugin_runner/src/transform_executor.rs
@@ -40,7 +40,7 @@ impl TransformExecutor {
             exported_plugin_transform: instance
                 .exports
                 .get_native_function::<(i32, i32, i32, i32, i32, i32, i32), i32>(
-                    "__plugin_process_impl",
+                    "__transform_plugin_process_impl",
                 )?,
             exported_plugin_free: instance
                 .exports
@@ -102,14 +102,26 @@ impl TransformExecutor {
         }
     }
 
+    /**
+     * Check compile-time versions of AST schema between the plugin and
+     * the host. Returns true if it's compatible, false otherwise.
+     *
+     * Host should appropriately handle if plugin is not compatible to the
+     * current runtime.
+     */
+    pub fn is_transform_schema_compatible(&self) -> bool {
+        todo!("Not supported yet");
+    }
+
     #[tracing::instrument(level = "info", skip_all)]
     pub fn transform(
         &mut self,
         program: &PluginSerializedBytes,
         config: &PluginSerializedBytes,
         context: &PluginSerializedBytes,
-        should_enable_comments_proxy: i32,
+        should_enable_comments_proxy: bool,
     ) -> Result<PluginSerializedBytes, Error> {
+        let should_enable_comments_proxy = if should_enable_comments_proxy { 1 } else { 0 };
         let guest_program_ptr = self.write_bytes_into_guest(program)?;
         let config_str_ptr = self.write_bytes_into_guest(config)?;
         let context_str_ptr = self.write_bytes_into_guest(context)?;
diff --git a/crates/swc_plugin_runner/tests/integration.rs b/crates/swc_plugin_runner/tests/integration.rs
diff --git a/tests/rust-plugins/swc_internal_plugin/Cargo.lock b/tests/rust-plugins/swc_internal_plugin/Cargo.lock
diff --git a/tests/rust-plugins/swc_internal_plugin/src/lib.rs b/tests/rust-plugins/swc_internal_plugin/src/lib.rs
