Implemented module ID global optimization using GlobalInformation.

Author: Lichu Acuña

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)
+    }
 }