Implemented module ID global optimization using GlobalInformation.

crates/turbopack-browser/src/chunking_context.rs

@@ -1,6 +1,6 @@
 use anyhow::{bail, Context, Result};
 use tracing::Instrument;
-use turbo_tasks::{debug::ValueDebug, RcStr, Value, ValueToString, Vc};
+use turbo_tasks::{RcStr, Value, ValueToString, Vc};
 use turbo_tasks_fs::FileSystemPath;
 use turbopack_core::{
  chunk::{
@@ -243,16 +243,6 @@ impl BrowserChunkingContext {
 
 #[turbo_tasks::value_impl]
 impl ChunkingContext for BrowserChunkingContext {
- #[turbo_tasks::function]
- async fn chunk_item_id_from_ident(
- self: Vc<Self>,
- ident: Vc<AssetIdent>,
- ) -> Result<Vc<ModuleId>> {
- let this = self.await?;
- dbg!(this.global_information.dbg().await?);
- Ok(ModuleId::String(ident.to_string().await?.clone_value()).cell())
- }
-
  #[turbo_tasks::function]
  fn name(&self) -> Vc<RcStr> {
  if let Some(name) = &self.name {
@@ -524,4 +514,9 @@ impl ChunkingContext for BrowserChunkingContext {
  self.chunk_item_id_from_ident(AsyncLoaderModule::asset_ident_for(module))
  })
  }
+
+ #[turbo_tasks::function]
+ async fn global_information(self: Vc<Self>) -> Result<Vc<OptionGlobalInformation>> {
+ Ok(self.await?.global_information)
+ }
 }

crates/turbopack-core/src/changed.rs

@@ -17,7 +17,7 @@ async fn get_referenced_output_assets(
  Ok(parent.references().await?.clone_value().into_iter())
 }
 
-async fn get_referenced_modules(
+pub async fn get_referenced_modules(
  parent: Vc<Box<dyn Module>>,
 ) -> Result<impl Iterator<Item = Vc<Box<dyn Module>>> + Send> {
  Ok(primary_referenced_modules(parent)

crates/turbopack-core/src/chunk/chunking_context.rs

@@ -4,7 +4,10 @@ use turbo_tasks::{trace::TraceRawVcs, RcStr, TaskInput, Upcast, Value, ValueToSt
 use turbo_tasks_fs::FileSystemPath;
 use turbo_tasks_hash::DeterministicHash;
 
-use super::{availability_info::AvailabilityInfo, ChunkableModule, EvaluatableAssets};
+use super::{
+ availability_info::AvailabilityInfo, global_information::OptionGlobalInformation,
+ ChunkableModule, EvaluatableAssets,
+};
 use crate::{
  chunk::{ChunkItem, ModuleId},
  environment::Environment,
@@ -114,10 +117,15 @@ pub trait ChunkingContext {
  availability_info: Value<AvailabilityInfo>,
  ) -> Result<Vc<EntryChunkGroupResult>>;
 
+ fn global_information(self: Vc<Self>) -> Vc<OptionGlobalInformation>;
+
  async fn chunk_item_id_from_ident(
  self: Vc<Self>,
  ident: Vc<AssetIdent>,
  ) -> Result<Vc<ModuleId>> {
+ if let Some(global_information) = &*self.global_information().await? {
+ return Ok(global_information.get_module_id(ident).await?);
+ }
  Ok(ModuleId::String(ident.to_string().await?.clone_value()).cell())
  }
 

crates/turbopack-core/src/chunk/global_information.rs

@@ -1,23 +1,28 @@
 use std::collections::HashMap;
 
-use turbo_tasks::{RcStr, Vc};
+use anyhow::Result;
+use turbo_tasks::{ValueToString, Vc};
 
 use super::ModuleId;
 use crate::ident::AssetIdent;
 
 #[turbo_tasks::value]
 #[derive(Clone, Debug)]
 pub struct GlobalInformation {
- pub test_str: Vc<RcStr>,
  pub module_id_map: HashMap<AssetIdent, ModuleId>,
 }
 
 impl GlobalInformation {
- pub fn get_module_id(&self, asset_ident: &AssetIdent) -> ModuleId {
- self.module_id_map.get(asset_ident).cloned().expect(
- "No module ID found for the given asset identifier. This is an internal Turbopack \
- error. Please report it.",
- )
+ pub async fn get_module_id(&self, asset_ident: Vc<AssetIdent>) -> Result<Vc<ModuleId>> {
+ let ident_str = asset_ident.to_string().await?;
+ let ident = asset_ident.await?;
+ let hashed_module_id = self.module_id_map.get(&ident);
+ if let Some(hashed_module_id) = hashed_module_id {
+ dbg!("Hashed module ID found", &ident_str, hashed_module_id);
+ return Ok(hashed_module_id.clone().cell());
+ }
+ dbg!("Hashed module ID not found", &ident_str);
+ return Ok(ModuleId::String(ident_str.clone_value()).cell());
  }
 }
 

crates/turbopack-nodejs/src/chunking_context.rs

@@ -2,7 +2,7 @@ use std::iter::once;
 
 use anyhow::{bail, Context, Result};
 use tracing::Instrument;
-use turbo_tasks::{debug::ValueDebug, RcStr, Value, ValueToString, Vc};
+use turbo_tasks::{RcStr, Value, ValueToString, Vc};
 use turbo_tasks_fs::FileSystemPath;
 use turbopack_core::{
  chunk::{
@@ -136,16 +136,6 @@ impl NodeJsChunkingContext {
 
 #[turbo_tasks::value_impl]
 impl NodeJsChunkingContext {
- #[turbo_tasks::function]
- async fn chunk_item_id_from_ident(
- self: Vc<Self>,
- ident: Vc<AssetIdent>,
- ) -> Result<Vc<ModuleId>> {
- let this = self.await?;
- dbg!(this.global_information.dbg().await?);
- Ok(ModuleId::String(ident.to_string().await?.clone_value()).cell())
- }
-
  #[turbo_tasks::function]
  fn new(this: Value<NodeJsChunkingContext>) -> Vc<Self> {
  this.into_value().cell()
@@ -395,4 +385,9 @@ impl ChunkingContext for NodeJsChunkingContext {
  self.chunk_item_id_from_ident(AsyncLoaderModule::asset_ident_for(module))
  })
  }
+
+ #[turbo_tasks::function]
+ async fn global_information(self: Vc<Self>) -> Result<Vc<OptionGlobalInformation>> {
+ Ok(self.await?.global_information)
+ }
 }