Turbopack: make ModulePart a TaskInput (#75364)

No significant perf impact

Author: mischnic

crates/next-api/src/server_actions.rs

@@ -246,7 +246,7 @@ async fn parse_actions(module: Vc<Box<dyn Module>>) -> Result<Vc<OptionActionMap
     if let Some(module) = Vc::try_resolve_downcast_type::<EcmascriptModulePartAsset>(module).await?
     {
         if matches!(
-            &*module.await?.part.await?,
+            module.await?.part,
             ModulePart::Evaluation | ModulePart::Facade
         ) {
             return Ok(Vc::cell(None));

crates/next-core/src/next_client_reference/ecmascript_client_reference/ecmascript_client_reference_transition.rs

@@ -50,7 +50,7 @@ impl Transition for NextEcmascriptClientReferenceTransition {
         let part = match &*reference_type {
             ReferenceType::EcmaScriptModules(EcmaScriptModulesReferenceSubType::ImportPart(
                 part,
-            )) => Some(*part),
+            )) => Some(part),
             _ => None,
         };
 
@@ -59,7 +59,7 @@ impl Transition for NextEcmascriptClientReferenceTransition {
         let this = self.await?;
 
         let ident = match part {
-            Some(part) => source.ident().with_part(*part),
+            Some(part) => source.ident().with_part(part.clone()),
             None => source.ident(),
         };
         let ident_ref = ident.await?;

crates/next-core/src/next_image/module.rs

@@ -74,7 +74,7 @@ impl CustomModuleType for StructuredImageModuleType {
         &self,
         source: Vc<Box<dyn Source>>,
         module_asset_context: Vc<ModuleAssetContext>,
-        _part: Option<Vc<ModulePart>>,
+        _part: Option<ModulePart>,
     ) -> Vc<Box<dyn Module>> {
         StructuredImageModuleType::create_module(
             source,

turbopack/crates/turbopack-core/src/ident.rs

@@ -24,7 +24,7 @@ pub struct AssetIdent {
     /// The modifiers of this asset (e.g. `client chunks`)
     pub modifiers: Vec<ResolvedVc<RcStr>>,
     /// The parts of the asset that are (ECMAScript) modules
-    pub parts: Vec<ResolvedVc<ModulePart>>,
+    pub parts: Vec<ModulePart>,
     /// The asset layer the asset was created from.
     pub layer: Option<ResolvedVc<RcStr>>,
 }
@@ -100,10 +100,9 @@ impl ValueToString for AssetIdent {
 
         if !self.parts.is_empty() {
             for part in self.parts.iter() {
-                let part = part.to_string().await?;
-                // facade is not included in ident as switching between facade and non-facade
-                // shouldn't change the ident
-                if part.as_str() != "facade" {
+                if !matches!(part, ModulePart::Facade) {
+                    // facade is not included in ident as switching between facade and non-facade
+                    // shouldn't change the ident
                     write!(s, " <{}>", part)?;
                 }
             }
@@ -149,7 +148,7 @@ impl AssetIdent {
     }
 
     #[turbo_tasks::function]
-    pub fn with_part(&self, part: ResolvedVc<ModulePart>) -> Vc<Self> {
+    pub fn with_part(&self, part: ModulePart) -> Vc<Self> {
         let mut this = self.clone();
         this.parts.push(part);
         Self::new(Value::new(this))
@@ -262,25 +261,25 @@ impl AssetIdent {
         }
         for part in parts.iter() {
             4_u8.deterministic_hash(&mut hasher);
-            match &*part.await? {
+            match part {
                 ModulePart::Evaluation => {
                     1_u8.deterministic_hash(&mut hasher);
                 }
                 ModulePart::Export(export) => {
                     2_u8.deterministic_hash(&mut hasher);
-                    export.await?.deterministic_hash(&mut hasher);
+                    export.deterministic_hash(&mut hasher);
                 }
                 ModulePart::RenamedExport {
                     original_export,
                     export,
                 } => {
                     3_u8.deterministic_hash(&mut hasher);
-                    original_export.await?.deterministic_hash(&mut hasher);
-                    export.await?.deterministic_hash(&mut hasher);
+                    original_export.deterministic_hash(&mut hasher);
+                    export.deterministic_hash(&mut hasher);
                 }
                 ModulePart::RenamedNamespace { export } => {
                     4_u8.deterministic_hash(&mut hasher);
-                    export.await?.deterministic_hash(&mut hasher);
+                    export.deterministic_hash(&mut hasher);
                 }
                 ModulePart::Internal(id) => {
                     5_u8.deterministic_hash(&mut hasher);

turbopack/crates/turbopack-core/src/reference_type.rs

@@ -43,7 +43,7 @@ pub enum ImportWithType {
 #[turbo_tasks::value(serialization = "auto_for_input")]
 #[derive(Debug, Default, Clone, Hash)]
 pub enum EcmaScriptModulesReferenceSubType {
-    ImportPart(ResolvedVc<ModulePart>),
+    ImportPart(ModulePart),
     Import,
     ImportWithType(ImportWithType),
     DynamicImport,

turbopack/crates/turbopack-core/src/resolve/mod.rs

@@ -3052,20 +3052,22 @@ async fn error_severity(resolve_options: Vc<ResolveOptions>) -> Result<ResolvedV
 /// ModulePart represents a part of a module.
 ///
 /// Currently this is used only for ESMs.
-#[turbo_tasks::value]
+#[derive(
+    Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, TraceRawVcs, TaskInput, NonLocalValue,
+)]
 pub enum ModulePart {
     /// Represents the side effects of a module. This part is evaluated even if
     /// all exports are unused.
     Evaluation,
     /// Represents an export of a module.
-    Export(ResolvedVc<RcStr>),
+    Export(RcStr),
     /// Represents a renamed export of a module.
     RenamedExport {
-        original_export: ResolvedVc<RcStr>,
-        export: ResolvedVc<RcStr>,
+        original_export: RcStr,
+        export: RcStr,
     },
     /// Represents a namespace object of a module exported as named export.
-    RenamedNamespace { export: ResolvedVc<RcStr> },
+    RenamedNamespace { export: RcStr },
     /// A pointer to a specific part.
     Internal(u32),
     /// A pointer to a specific part, but with evaluation.
@@ -3079,76 +3081,64 @@ pub enum ModulePart {
     Facade,
 }
 
-#[turbo_tasks::value_impl]
 impl ModulePart {
-    #[turbo_tasks::function]
-    pub fn evaluation() -> Vc<Self> {
-        ModulePart::Evaluation.cell()
+    pub fn evaluation() -> Self {
+        ModulePart::Evaluation
     }
-    #[turbo_tasks::function]
-    pub fn export(export: RcStr) -> Vc<Self> {
-        ModulePart::Export(ResolvedVc::cell(export)).cell()
+
+    pub fn export(export: RcStr) -> Self {
+        ModulePart::Export(export)
     }
-    #[turbo_tasks::function]
-    pub fn renamed_export(original_export: RcStr, export: RcStr) -> Vc<Self> {
+
+    pub fn renamed_export(original_export: RcStr, export: RcStr) -> Self {
         ModulePart::RenamedExport {
-            original_export: ResolvedVc::cell(original_export),
-            export: ResolvedVc::cell(export),
+            original_export,
+            export,
         }
-        .cell()
     }
-    #[turbo_tasks::function]
-    pub fn renamed_namespace(export: RcStr) -> Vc<Self> {
-        ModulePart::RenamedNamespace {
-            export: ResolvedVc::cell(export),
-        }
-        .cell()
+
+    pub fn renamed_namespace(export: RcStr) -> Self {
+        ModulePart::RenamedNamespace { export }
     }
-    #[turbo_tasks::function]
-    pub fn internal(id: u32) -> Vc<Self> {
-        ModulePart::Internal(id).cell()
+
+    pub fn internal(id: u32) -> Self {
+        ModulePart::Internal(id)
     }
-    #[turbo_tasks::function]
-    pub fn internal_evaluation(id: u32) -> Vc<Self> {
-        ModulePart::InternalEvaluation(id).cell()
+
+    pub fn internal_evaluation(id: u32) -> Self {
+        ModulePart::InternalEvaluation(id)
     }
-    #[turbo_tasks::function]
-    pub fn locals() -> Vc<Self> {
-        ModulePart::Locals.cell()
+
+    pub fn locals() -> Self {
+        ModulePart::Locals
     }
-    #[turbo_tasks::function]
-    pub fn exports() -> Vc<Self> {
-        ModulePart::Exports.cell()
+
+    pub fn exports() -> Self {
+        ModulePart::Exports
     }
-    #[turbo_tasks::function]
-    pub fn facade() -> Vc<Self> {
-        ModulePart::Facade.cell()
+
+    pub fn facade() -> Self {
+        ModulePart::Facade
     }
 }
 
-#[turbo_tasks::value_impl]
-impl ValueToString for ModulePart {
-    #[turbo_tasks::function]
-    async fn to_string(&self) -> Result<Vc<RcStr>> {
-        Ok(Vc::cell(match self {
-            ModulePart::Evaluation => "module evaluation".into(),
-            ModulePart::Export(export) => format!("export {}", export.await?).into(),
+impl Display for ModulePart {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ModulePart::Evaluation => f.write_str("module evaluation"),
+            ModulePart::Export(export) => write!(f, "export {}", export),
             ModulePart::RenamedExport {
                 original_export,
                 export,
-            } => {
-                let original_export = original_export.await?;
-                let export = export.await?;
-                format!("export {} as {}", original_export, export).into()
-            }
+            } => write!(f, "export {} as {}", original_export, export),
             ModulePart::RenamedNamespace { export } => {
-                format!("export * as {}", export.await?).into()
+                write!(f, "export * as {}", export)
             }
-            ModulePart::Internal(id) => format!("internal part {}", id).into(),
-            ModulePart::InternalEvaluation(id) => format!("internal part {}", id).into(),
-            ModulePart::Locals => "locals".into(),
-            ModulePart::Exports => "exports".into(),
-            ModulePart::Facade => "facade".into(),
-        }))
+            ModulePart::Internal(id) => write!(f, "internal part {}", id),
+            ModulePart::InternalEvaluation(id) => write!(f, "internal part {}", id),
+            ModulePart::Locals => f.write_str("locals"),
+            ModulePart::Exports => f.write_str("exports"),
+            ModulePart::Facade => f.write_str("facade"),
+        }
     }
 }

turbopack/crates/turbopack-ecmascript/src/references/esm/base.rs

@@ -117,7 +117,7 @@ pub struct EsmAssetReference {
     pub request: ResolvedVc<Request>,
     pub annotations: ImportAnnotations,
     pub issue_source: IssueSource,
-    pub export_name: Option<ResolvedVc<ModulePart>>,
+    pub export_name: Option<ModulePart>,
     pub import_externals: bool,
 }
 
@@ -137,7 +137,7 @@ impl EsmAssetReference {
         request: ResolvedVc<Request>,
         issue_source: IssueSource,
         annotations: Value<ImportAnnotations>,
-        export_name: Option<ResolvedVc<ModulePart>>,
+        export_name: Option<ModulePart>,
         import_externals: bool,
     ) -> Vc<Self> {
         Self::cell(EsmAssetReference {
@@ -166,20 +166,20 @@ impl ModuleReference for EsmAssetReference {
         let ty = if matches!(self.annotations.module_type(), Some("json")) {
             EcmaScriptModulesReferenceSubType::ImportWithType(ImportWithType::Json)
         } else if let Some(part) = &self.export_name {
-            EcmaScriptModulesReferenceSubType::ImportPart(*part)
+            EcmaScriptModulesReferenceSubType::ImportPart(part.clone())
         } else {
             EcmaScriptModulesReferenceSubType::Import
         };
 
         if let Request::Module { module, .. } = &*self.request.await? {
             if module == TURBOPACK_PART_IMPORT_SOURCE {
-                if let Some(part) = self.export_name {
+                if let Some(part) = &self.export_name {
                     let module: ResolvedVc<crate::EcmascriptModuleAsset> =
                         ResolvedVc::try_downcast_type(self.origin)
                             .expect("EsmAssetReference origin should be a EcmascriptModuleAsset");
 
                     return Ok(ModuleResolveResult::module(
-                        EcmascriptModulePartAsset::select_part(*module, *part)
+                        EcmascriptModulePartAsset::select_part(*module, part.clone())
                             .to_resolved()
                             .await?,
                     )
@@ -199,21 +199,17 @@ impl ModuleReference for EsmAssetReference {
         )
         .await?;
 
-        if let Some(part) = self.export_name {
-            let part = part.await?;
-            if let &ModulePart::Export(export_name) = &*part {
-                for &module in result.primary_modules().await? {
-                    if let Some(module) = ResolvedVc::try_downcast(module) {
-                        let export = export_name.await?;
-                        if *is_export_missing(*module, export.clone_value()).await? {
-                            InvalidExport {
-                                export: export_name,
-                                module,
-                                source: self.issue_source.clone(),
-                            }
-                            .resolved_cell()
-                            .emit();
+        if let Some(ModulePart::Export(export_name)) = &self.export_name {
+            for &module in result.primary_modules().await? {
+                if let Some(module) = ResolvedVc::try_downcast(module) {
+                    if *is_export_missing(*module, export_name.clone()).await? {
+                        InvalidExport {
+                            export: export_name.clone(),
+                            module,
+                            source: self.issue_source.clone(),
                         }
+                        .resolved_cell()
+                        .emit();
                     }
                 }
             }
@@ -413,7 +409,7 @@ fn var_decl_with_span(mut decl: Stmt, span: Span) -> Stmt {
 
 #[turbo_tasks::value(shared)]
 pub struct InvalidExport {
-    export: ResolvedVc<RcStr>,
+    export: RcStr,
     module: ResolvedVc<Box<dyn EcmascriptChunkPlaceable>>,
     source: IssueSource,
 }
@@ -429,7 +425,7 @@ impl Issue for InvalidExport {
     async fn title(&self) -> Result<Vc<StyledString>> {
         Ok(StyledString::Line(vec![
             StyledString::Text("Export ".into()),
-            StyledString::Code(self.export.await?.clone_value()),
+            StyledString::Code(self.export.clone()),
             StyledString::Text(" doesn't exist in target module".into()),
         ])
         .cell())
@@ -447,18 +443,17 @@ impl Issue for InvalidExport {
 
     #[turbo_tasks::function]
     async fn description(&self) -> Result<Vc<OptionStyledString>> {
-        let export = self.export.await?;
         let export_names = all_known_export_names(*self.module).await?;
         let did_you_mean = export_names
             .iter()
-            .map(|s| (s, jaro(export.as_str(), s.as_str())))
+            .map(|s| (s, jaro(self.export.as_str(), s.as_str())))
             .max_by(|a, b| a.1.partial_cmp(&b.1).unwrap())
             .map(|(s, _)| s);
         Ok(Vc::cell(Some(
             StyledString::Stack(vec![
                 StyledString::Line(vec![
                     StyledString::Text("The export ".into()),
-                    StyledString::Code(export.clone_value()),
+                    StyledString::Code(self.export.clone()),
                     StyledString::Text(" was not found in module ".into()),
                     StyledString::Strong(self.module.ident().to_string().await?.clone_value()),
                     StyledString::Text(".".into()),