Turbopack: add flags to AvailabilityInfo

Author: sokra

Cargo.lock

@@ -16,6 +16,7 @@ workspace = true
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 auto-hash-map = { workspace = true }
+bitfield = { workspace = true }
 browserslist-rs = { workspace = true }
 bytes-str = { workspace = true }
 const_format = { workspace = true }

turbopack/crates/turbopack-core/Cargo.toml

@@ -1,10 +1,17 @@
 use anyhow::Result;
+use bitfield::bitfield;
 use serde::{Deserialize, Serialize};
-use turbo_rcstr::{RcStr, rcstr};
+use turbo_rcstr::RcStr;
 use turbo_tasks::{NonLocalValue, ResolvedVc, TaskInput, Vc, trace::TraceRawVcs};
 
 use super::available_modules::{AvailableModules, AvailableModulesSet};
 
+bitfield! {
+    #[derive(Clone, Copy, Default, TaskInput, TraceRawVcs, NonLocalValue, Serialize, Deserialize, PartialEq, Eq, Hash)]
+    pub struct AvailabilityFlags(u8);
+    impl Debug;
+}
+
 #[derive(
     Eq,
     PartialEq,
@@ -18,49 +25,48 @@ use super::available_modules::{AvailableModules, AvailableModulesSet};
     Serialize,
     Deserialize,
 )]
-pub enum AvailabilityInfo {
-    /// Availability of modules is tracked, but no modules are available
-    Root,
+pub struct AvailabilityInfo {
+    flags: AvailabilityFlags,
     /// There are modules already available.
-    Complete {
-        available_modules: ResolvedVc<AvailableModules>,
-    },
+    available_modules: Option<ResolvedVc<AvailableModules>>,
 }
 
 impl AvailabilityInfo {
     pub fn root() -> Self {
-        AvailabilityInfo::Root
+        Self {
+            flags: AvailabilityFlags::default(),
+            available_modules: None,
+        }
     }
 
     pub fn available_modules(&self) -> Option<ResolvedVc<AvailableModules>> {
-        match self {
-            Self::Root => None,
-            Self::Complete {
-                available_modules, ..
-            } => Some(*available_modules),
-        }
+        self.available_modules
     }
 
     pub async fn with_modules(self, modules: Vc<AvailableModulesSet>) -> Result<Self> {
-        Ok(match self {
-            AvailabilityInfo::Root => AvailabilityInfo::Complete {
-                available_modules: AvailableModules::new(modules).to_resolved().await?,
-            },
-            AvailabilityInfo::Complete { available_modules } => AvailabilityInfo::Complete {
-                available_modules: available_modules
-                    .with_modules(modules)
-                    .to_resolved()
-                    .await?,
-            },
+        Ok(if let Some(available_modules) = self.available_modules {
+            Self {
+                flags: self.flags,
+                available_modules: Some(
+                    available_modules
+                        .with_modules(modules)
+                        .to_resolved()
+                        .await?,
+                ),
+            }
+        } else {
+            Self {
+                flags: self.flags,
+                available_modules: Some(AvailableModules::new(modules).to_resolved().await?),
+            }
         })
     }
 
     pub async fn ident(&self) -> Result<Option<RcStr>> {
-        Ok(match self {
-            AvailabilityInfo::Root => None,
-            AvailabilityInfo::Complete { available_modules } => {
-                Some(available_modules.hash().await?.to_string().into())
-            }
+        Ok(if let Some(available_modules) = self.available_modules {
+            Some(available_modules.hash().await?.to_string().into())
+        } else {
+            None
         })
     }
 }