chore: update hmr-poc

Cargo.toml

@@ -95,6 +95,7 @@ rolldown_plugin_json                    = { version = "0.1.0", path = "./crates/
 rolldown_plugin_load_fallback           = { version = "0.1.0", path = "./crates/rolldown_plugin_load_fallback" }
 rolldown_plugin_manifest                = { version = "0.1.0", path = "./crates/rolldown_plugin_manifest" }
 rolldown_plugin_module_preload_polyfill = { version = "0.1.0", path = "./crates/rolldown_plugin_module_preload_polyfill" }
+rolldown_plugin_react                   = { version = "0.1.0", path = "./crates/rolldown_plugin_react" }
 rolldown_plugin_replace                 = { version = "0.1.0", path = "./crates/rolldown_plugin_replace" }
 rolldown_plugin_transform               = { version = "0.1.0", path = "./crates/rolldown_plugin_transform" }
 rolldown_plugin_vite_resolve            = { version = "0.1.0", path = "./crates/rolldown_plugin_vite_resolve" }

crates/rolldown/src/bundler.rs

@@ -4,20 +4,30 @@ use super::stages::{
 };
 use crate::{
   bundler_builder::BundlerBuilder,
-  stages::{generate_stage::GenerateStage, scan_stage::ScanStage},
+  module_loader::hmr_module_loader::HmrModuleLoader,
+  stages::{
+    generate_stage::{render_hmr_chunk::render_hmr_chunk, GenerateStage},
+    scan_stage::ScanStage,
+  },
+  type_alias::IndexEcmaAst,
   types::bundle_output::BundleOutput,
   watcher::watcher::{wait_for_change, Watcher},
   BundlerOptions, SharedOptions, SharedResolver,
 };
 use anyhow::Result;
+use arcstr::ArcStr;
+
+use rolldown_common::{
+  ModuleIdx, ModuleTable, NormalizedBundlerOptions, SharedFileEmitter, SymbolRefDb,
+};
 
-use rolldown_common::{NormalizedBundlerOptions, SharedFileEmitter};
 use rolldown_error::{BuildDiagnostic, BuildResult};
 use rolldown_fs::{FileSystem, OsFileSystem};
 use rolldown_plugin::{
   HookBuildEndArgs, HookRenderErrorArgs, SharedPluginDriver, __inner::SharedPluginable,
 };
 use rolldown_std_utils::OptionExt;
+use rustc_hash::FxHashMap;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 use tracing_chrome::FlushGuard;
@@ -31,6 +41,10 @@ pub struct Bundler {
   pub(crate) plugin_driver: SharedPluginDriver,
   pub(crate) warnings: Vec<BuildDiagnostic>,
   pub(crate) _log_guard: Option<FlushGuard>,
+  pub(crate) previous_module_table: ModuleTable,
+  pub(crate) previous_module_id_to_modules: FxHashMap<ArcStr, ModuleIdx>,
+  pub(crate) pervious_index_ecma_ast: IndexEcmaAst,
+  pub(crate) pervious_symbols: SymbolRefDb,
 }
 
 impl Bundler {
@@ -46,26 +60,9 @@ impl Bundler {
 impl Bundler {
   #[tracing::instrument(level = "debug", skip_all)]
   pub async fn write(&mut self) -> BuildResult<BundleOutput> {
-    let dir = self.options.cwd.join(&self.options.dir);
-
     let mut output = self.bundle_up(/* is_write */ true).await?;
 
-    self.fs.create_dir_all(&dir).map_err(|err| {
-      anyhow::anyhow!("Could not create directory for output chunks: {:?}", dir).context(err)
-    })?;
-
-    for chunk in &output.assets {
-      let dest = dir.join(chunk.filename());
-      if let Some(p) = dest.parent() {
-        if !self.fs.exists(p) {
-          self.fs.create_dir_all(p).unwrap();
-        }
-      };
-      self
-        .fs
-        .write(&dest, chunk.content_as_bytes())
-        .map_err(|err| anyhow::anyhow!("Failed to write file in {:?}", dest).context(err))?;
-    }
+    self.write_file_to_disk(&output)?;
 
     self.plugin_driver.write_bundle(&mut output.assets, &self.options).await?;
 
@@ -129,6 +126,57 @@ impl Bundler {
     Ok(scan_stage_output)
   }
 
+  #[allow(clippy::unused_async)]
+  pub async fn hmr_rebuild(&mut self, changed_files: Vec<String>) -> BuildResult<BundleOutput> {
+    let hmr_module_loader = HmrModuleLoader::new(
+      Arc::clone(&self.options),
+      Arc::clone(&self.plugin_driver),
+      self.fs,
+      Arc::clone(&self.resolver),
+      std::mem::take(&mut self.previous_module_id_to_modules),
+      std::mem::take(&mut self.previous_module_table),
+      std::mem::take(&mut self.pervious_index_ecma_ast),
+      std::mem::take(&mut self.pervious_symbols),
+    )?;
+
+    let mut hmr_module_loader_output = hmr_module_loader.fetch_changed_files(changed_files).await?;
+
+    let output = render_hmr_chunk(&self.options, &mut hmr_module_loader_output);
+
+    self.write_file_to_disk(&output)?;
+
+    // store last build modules info
+    self.previous_module_table = hmr_module_loader_output.module_table;
+    self.previous_module_id_to_modules = hmr_module_loader_output.module_id_to_modules;
+    self.pervious_index_ecma_ast = hmr_module_loader_output.index_ecma_ast;
+    self.pervious_symbols = hmr_module_loader_output.symbol_ref_db;
+
+    Ok(output)
+  }
+
+  fn write_file_to_disk(&self, output: &BundleOutput) -> Result<()> {
+    let dir = self.options.cwd.join(&self.options.dir);
+
+    self.fs.create_dir_all(&dir).map_err(|err| {
+      anyhow::anyhow!("Could not create directory for output chunks: {:?}", dir).context(err)
+    })?;
+
+    for chunk in &output.assets {
+      let dest = dir.join(chunk.filename());
+      if let Some(p) = dest.parent() {
+        if !self.fs.exists(p) {
+          self.fs.create_dir_all(p).unwrap();
+        }
+      };
+      self
+        .fs
+        .write(&dest, chunk.content_as_bytes())
+        .map_err(|err| anyhow::anyhow!("Failed to write file in {:?}", dest).context(err))?;
+    }
+
+    Ok(())
+  }
+
   async fn try_build(&mut self) -> BuildResult<LinkStageOutput> {
     let build_info = self.scan().await?;
     Ok(LinkStage::new(build_info, &self.options).link())
@@ -170,6 +218,12 @@ impl Bundler {
 
     output.watch_files = self.plugin_driver.watch_files.iter().map(|f| f.clone()).collect();
 
+    // store last build modules info
+    self.previous_module_table = link_stage_output.module_table;
+    self.previous_module_id_to_modules = link_stage_output.module_id_to_modules;
+    self.pervious_index_ecma_ast = link_stage_output.ast_table;
+    self.pervious_symbols = link_stage_output.symbol_db;
+
     Ok(output)
   }
 

crates/rolldown/src/bundler_builder.rs

@@ -1,9 +1,11 @@
 use std::sync::Arc;
 
-use rolldown_common::FileEmitter;
+use oxc_index::IndexVec;
+use rolldown_common::{FileEmitter, ModuleTable, SymbolRefDb};
 use rolldown_fs::OsFileSystem;
 use rolldown_plugin::{PluginDriver, __inner::SharedPluginable};
 use rolldown_resolver::Resolver;
+use rustc_hash::FxHashMap;
 
 use crate::{
   utils::{
@@ -44,6 +46,10 @@ impl BundlerBuilder {
       fs: OsFileSystem,
       warnings,
       _log_guard: maybe_guard,
+      previous_module_table: ModuleTable::default(),
+      previous_module_id_to_modules: FxHashMap::default(),
+      pervious_index_ecma_ast: IndexVec::default(),
+      pervious_symbols: SymbolRefDb::default(),
     }
   }
 

crates/rolldown/src/ecmascript/format/app.rs

@@ -1,9 +1,10 @@
+use rolldown_common::{ChunkKind, Module};
 use rolldown_sourcemap::SourceJoiner;
 
 use crate::{ecmascript::ecma_generator::RenderedModuleSources, types::generator::GenerateContext};
 
 pub fn render_app<'code>(
-  _ctx: &GenerateContext<'_>,
+  ctx: &GenerateContext<'_>,
   hashbang: Option<&'code str>,
   banner: Option<&'code str>,
   intro: Option<&'code str>,
@@ -25,14 +26,34 @@ pub fn render_app<'code>(
   }
 
   // chunk content
-  module_sources.iter().for_each(|(_, _, module_render_output)| {
+  module_sources.iter().for_each(|(module_idx, _, module_render_output)| {
     if let Some(emitted_sources) = module_render_output {
-      for source in emitted_sources.as_ref() {
+      let is_runtime = ctx.link_output.runtime.id() == *module_idx;
+      if !is_runtime {
+        source_joiner.append_source(format!(
+          "rolldown_runtime.define('{}',function(require, module, exports){{\n",
+          // Here need to care about virtual module `\0`, the oxc codegen will escape it, so here also escape it
+          ctx.link_output.module_table.modules[*module_idx].stable_id().escape_default()
+        ));
+      }
+      for source in emitted_sources.iter() {
         source_joiner.append_source(source);
       }
+      if !is_runtime {
+        source_joiner.append_source("});".to_string());
+      }
     }
   });
 
+  if let ChunkKind::EntryPoint { module: entry_id, .. } = ctx.chunk.kind {
+    if let Module::Normal(entry_module) = &ctx.link_output.module_table.modules[entry_id] {
+      source_joiner.append_source(format!(
+        "rolldown_runtime.require('{}');",
+        entry_module.stable_id.escape_default()
+      ));
+    }
+  }
+
   if let Some(outro) = outro {
     source_joiner.append_source(outro);
   }

crates/rolldown/src/module_finalizers/isolating/impl_visit_mut.rs

@@ -112,6 +112,17 @@ impl<'me, 'ast> VisitMut<'ast> for IsolatingModuleFinalizer<'me, 'ast> {
 
     walk_mut::walk_call_expression(self, expr);
   }
+
+  fn visit_static_member_expression(&mut self, expr: &mut ast::StaticMemberExpression<'ast>) {
+    // replace `import.meta.hot` -> `module.hot`
+    if let Expression::MetaProperty(meta) = &expr.object {
+      if expr.property.name == "hot" && meta.meta.name == "import" && meta.property.name == "meta" {
+        expr.object = self.snippet.id_ref_expr("module", SPAN);
+      }
+    }
+
+    walk_mut::walk_static_member_expression(self, expr);
+  }
 }
 
 impl<'me, 'ast> IsolatingModuleFinalizer<'me, 'ast> {

crates/rolldown/src/module_finalizers/isolating/mod.rs

@@ -9,12 +9,14 @@ use rustc_hash::FxHashSet;
 
 mod impl_visit_mut;
 
+#[allow(dead_code)]
 pub struct IsolatingModuleFinalizerContext<'me> {
   pub module: &'me NormalModule,
   pub modules: &'me IndexModules,
   pub symbol_db: &'me SymbolRefDb,
 }
 
+#[allow(dead_code)]
 pub struct IsolatingModuleFinalizer<'me, 'ast> {
   pub ctx: &'me IsolatingModuleFinalizerContext<'me>,
   pub scope: &'me AstScopes,