[turbopack] Remove the final uses of Value<..> and delete the type (#80144)

Remove the final uses of `Value<..>` and destroy it.

### Why?
The `Value<>` type is confusing and error prone, lets destroy it!

As discussed over slack, turbo_tasks::Value type always implements is_resolved as true and is_transient as false which is incorrect and can enable smuggling transient vcs into turbo tasks.

• https://vercel.slack.com/archives/C03EWR7LGEN/p1743456121241529
• https://vercel.slack.com/archives/C04NGV98TPS/p1743455453764879

Author: lukesandberg

crates/next-api/src/pages.rs

@@ -29,8 +29,8 @@ use serde::{Deserialize, Serialize};
 use tracing::Instrument;
 use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{
-    Completion, FxIndexMap, NonLocalValue, ResolvedVc, TaskInput, Value, ValueToString, Vc,
-    fxindexmap, fxindexset, trace::TraceRawVcs,
+    Completion, FxIndexMap, NonLocalValue, ResolvedVc, TaskInput, ValueToString, Vc, fxindexmap,
+    fxindexset, trace::TraceRawVcs,
 };
 use turbo_tasks_fs::{
     self, File, FileContent, FileSystem, FileSystemPath, FileSystemPathOption, VirtualFileSystem,
@@ -635,7 +635,7 @@ impl PagesProject {
                     NextMode::Build => rcstr!("next/dist/client/next-turbopack.js"),
                 },
             )),
-            Value::new(EcmaScriptModulesReferenceSubType::Undefined),
+            EcmaScriptModulesReferenceSubType::Undefined,
             false,
             None,
         )

crates/next-core/src/app_segment_config.rs

@@ -272,7 +272,7 @@ pub async fn parse_segment_config_from_source(
 
     let result = &*parse(
         *source,
-        turbo_tasks::Value::new(if path.path.ends_with(".ts") {
+        if path.path.ends_with(".ts") {
             EcmascriptModuleAssetType::Typescript {
                 tsx: false,
                 analyze_types: false,
@@ -284,7 +284,7 @@ pub async fn parse_segment_config_from_source(
             }
         } else {
             EcmascriptModuleAssetType::Ecmascript
-        }),
+        },
         EcmascriptInputTransforms::empty(),
     )
     .await?;

turbopack/crates/turbo-tasks-testing/tests/all_in_one.rs

@@ -4,7 +4,7 @@
 
 use anyhow::{Result, bail};
 use turbo_rcstr::{RcStr, rcstr};
-use turbo_tasks::{ResolvedVc, Value, ValueToString, Vc};
+use turbo_tasks::{ResolvedVc, TaskInput, ValueToString, Vc};
 use turbo_tasks_testing::{Registration, register, run};
 
 static REGISTRATION: Registration = register!();
@@ -27,7 +27,7 @@ async fn all_in_one() {
         }
         .into();
 
-        let result = my_function(a, b.get_last(), c, Value::new(MyEnumValue::Yeah(42)));
+        let result = my_function(a, b.get_last(), c, MyEnumValue::Yeah(42));
         assert_eq!(*result.my_trait_function().await?, "42");
         assert_eq!(*result.my_trait_function2().await?, "42");
         assert_eq!(*result.my_trait_function3().await?, "4242");
@@ -63,12 +63,12 @@ async fn all_in_one() {
     .unwrap()
 }
 
-#[turbo_tasks::value(transparent, serialization = "auto_for_input")]
+#[turbo_tasks::value(transparent)]
 #[derive(Debug, Clone, Hash)]
 struct MyTransparentValue(u32);
 
-#[turbo_tasks::value(shared, serialization = "auto_for_input")]
-#[derive(Debug, Clone, Hash)]
+#[turbo_tasks::value(shared)]
+#[derive(Debug, Clone, Hash, TaskInput)]
 enum MyEnumValue {
     Yeah(u32),
     Nah,
@@ -159,12 +159,12 @@ async fn my_function(
     a: Vc<MyTransparentValue>,
     b: Vc<MyEnumValue>,
     c: Vc<MyStructValue>,
-    d: Value<MyEnumValue>,
+    d: MyEnumValue,
 ) -> Result<Vc<MyStructValue>> {
     assert_eq!(*a.await?, 4242);
     assert_eq!(*b.await?, MyEnumValue::Yeah(42));
     assert_eq!(c.await?.value, 42);
-    assert_eq!(d.into_value(), MyEnumValue::Yeah(42));
+    assert_eq!(d, MyEnumValue::Yeah(42));
     Ok(c)
 }
 

turbopack/crates/turbo-tasks/src/lib.rs

@@ -123,7 +123,7 @@ pub use state::{State, TransientState};
 pub use task::{SharedReference, TypedSharedReference, task_input::TaskInput};
 pub use trait_ref::{IntoTraitRef, TraitRef};
 pub use turbo_tasks_macros::{TaskInput, function, value_impl};
-pub use value::{TransientInstance, TransientValue, Value};
+pub use value::{TransientInstance, TransientValue};
 pub use value_type::{TraitMethod, TraitType, ValueType};
 pub use vc::{
     Dynamic, NonLocalValue, OperationValue, OperationVc, OptionVcExt, ReadVcFuture, ResolvedVc,

turbopack/crates/turbo-tasks/src/marker_trait.rs

@@ -78,7 +78,6 @@ macro_rules! impl_auto_marker_trait {
         {}
         unsafe impl<T: $trait> $trait for $crate::State<T> {}
         unsafe impl<T: $trait> $trait for $crate::TransientState<T> {}
-        unsafe impl<T: $trait> $trait for $crate::Value<T> {}
         unsafe impl<T: $trait> $trait for $crate::TransientValue<T> {}
         unsafe impl<T: $trait> $trait for $crate::TransientInstance<T> {}
 

turbopack/crates/turbo-tasks/src/task/task_input.rs

@@ -1,6 +1,5 @@
 use std::{
-    any::Any, collections::BTreeMap, fmt::Debug, future::Future, hash::Hash, sync::Arc,
-    time::Duration,
+    collections::BTreeMap, fmt::Debug, future::Future, hash::Hash, sync::Arc, time::Duration,
 };
 
 use anyhow::Result;
@@ -9,7 +8,7 @@ use serde::{Deserialize, Serialize};
 use turbo_rcstr::RcStr;
 
 use crate::{
-    MagicAny, ResolvedVc, TaskId, TransientInstance, TransientValue, Value, ValueTypeId, Vc,
+    MagicAny, ResolvedVc, TaskId, TransientInstance, TransientValue, ValueTypeId, Vc,
     trace::TraceRawVcs,
 };
 
@@ -170,29 +169,6 @@ where
     }
 }
 
-impl<T> TaskInput for Value<T>
-where
-    T: Any
-        + std::fmt::Debug
-        + Clone
-        + std::hash::Hash
-        + Eq
-        + Send
-        + Sync
-        + Serialize
-        + for<'de> Deserialize<'de>
-        + TraceRawVcs
-        + 'static,
-{
-    fn is_resolved(&self) -> bool {
-        true
-    }
-
-    fn is_transient(&self) -> bool {
-        false
-    }
-}
-
 impl<T> TaskInput for TransientValue<T>
 where
     T: MagicAny + Clone + Debug + Hash + Eq + TraceRawVcs + 'static,

turbopack/crates/turbo-tasks/src/value.rs

@@ -1,68 +1,12 @@
 use std::{fmt::Debug, marker::PhantomData, ops::Deref};
 
 use anyhow::Result;
-use serde::{Deserialize, Serialize};
 
 use crate::{
-    ReadRef, SharedReference,
-    debug::{ValueDebugFormat, ValueDebugString},
+    SharedReference,
     trace::{TraceRawVcs, TraceRawVcsContext},
 };
 
-/// Pass a value by value (`Value<Xxx>`) instead of by reference (`Vc<Xxx>`).
-///
-/// Persistent, requires serialization.
-#[derive(Debug, PartialEq, Eq, Clone, Hash, Serialize, Deserialize)]
-pub struct Value<T> {
-    inner: T,
-}
-
-impl<T> Value<T> {
-    pub fn new(value: T) -> Self {
-        Self { inner: value }
-    }
-
-    pub fn into_value(self) -> T {
-        self.inner
-    }
-}
-
-impl<T> Deref for Value<T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl<T: Copy> Copy for Value<T> {}
-
-impl<T: Default> Default for Value<T> {
-    fn default() -> Self {
-        Value::new(Default::default())
-    }
-}
-
-impl<T: ValueDebugFormat> Value<T> {
-    pub async fn dbg(&self) -> Result<ReadRef<ValueDebugString>> {
-        self.dbg_depth(usize::MAX).await
-    }
-
-    pub async fn dbg_depth(&self, depth: usize) -> Result<ReadRef<ValueDebugString>> {
-        self.inner
-            .value_debug_format(depth)
-            .try_to_value_debug_string()
-            .await?
-            .await
-    }
-}
-
-impl<T: TraceRawVcs> TraceRawVcs for Value<T> {
-    fn trace_raw_vcs(&self, trace_context: &mut TraceRawVcsContext) {
-        self.inner.trace_raw_vcs(trace_context)
-    }
-}
-
 /// Pass a value by value (`Value<Xxx>`) instead of by reference (`Vc<Xxx>`).
 ///
 /// Doesn't require serialization, and won't be stored in the persistent cache

turbopack/crates/turbopack-browser/src/chunking_context.rs

@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize};
 use tracing::Instrument;
 use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{
-    NonLocalValue, ResolvedVc, TaskInput, TryJoinIterExt, Upcast, Value, ValueToString, Vc,
+    NonLocalValue, ResolvedVc, TaskInput, TryJoinIterExt, Upcast, ValueToString, Vc,
     trace::TraceRawVcs,
 };
 use turbo_tasks_fs::FileSystemPath;
@@ -38,7 +38,7 @@ use crate::ecmascript::{
 };
 
 #[turbo_tasks::value]
-#[derive(Debug, Clone, Copy, Hash)]
+#[derive(Debug, Clone, Copy, Hash, TaskInput)]
 pub enum CurrentChunkMethod {
     StringLiteral,
     DocumentCurrentScript,
@@ -161,7 +161,7 @@ impl BrowserChunkingContextBuilder {
     }
 
     pub fn build(self) -> Vc<BrowserChunkingContext> {
-        BrowserChunkingContext::new(Value::new(self.chunking_context))
+        BrowserChunkingContext::new(self.chunking_context)
     }
 }
 
@@ -172,7 +172,7 @@ impl BrowserChunkingContextBuilder {
 /// It splits "node_modules" separately as these are less likely to change
 /// during development
 #[turbo_tasks::value(serialization = "auto_for_input")]
-#[derive(Debug, Clone, Hash)]
+#[derive(Debug, Clone, Hash, TaskInput)]
 pub struct BrowserChunkingContext {
     name: Option<RcStr>,
     /// The root path of the project
@@ -295,8 +295,8 @@ impl BrowserChunkingContext {
 #[turbo_tasks::value_impl]
 impl BrowserChunkingContext {
     #[turbo_tasks::function]
-    fn new(this: Value<BrowserChunkingContext>) -> Vc<Self> {
-        this.into_value().cell()
+    fn new(this: BrowserChunkingContext) -> Vc<Self> {
+        this.cell()
     }
 
     #[turbo_tasks::function]
@@ -323,7 +323,7 @@ impl BrowserChunkingContext {
         ident: Vc<AssetIdent>,
         evaluatable_assets: Vc<EvaluatableAssets>,
         other_chunks: Vc<OutputAssets>,
-        source: Value<EcmascriptDevChunkListSource>,
+        source: EcmascriptDevChunkListSource,
     ) -> Vc<Box<dyn OutputAsset>> {
         Vc::upcast(EcmascriptDevChunkList::new(
             self,
@@ -565,7 +565,7 @@ impl ChunkingContext for BrowserChunkingContext {
                         ident,
                         EvaluatableAssets::empty(),
                         Vc::cell(assets.clone()),
-                        Value::new(EcmascriptDevChunkListSource::Dynamic),
+                        EcmascriptDevChunkListSource::Dynamic,
                     )
                     .to_resolved()
                     .await?,
@@ -634,7 +634,7 @@ impl ChunkingContext for BrowserChunkingContext {
                         ident,
                         entries,
                         other_assets,
-                        Value::new(EcmascriptDevChunkListSource::Entry),
+                        EcmascriptDevChunkListSource::Entry,
                     )
                     .to_resolved()
                     .await?,

turbopack/crates/turbopack-browser/src/ecmascript/evaluate/chunk.rs

@@ -5,7 +5,7 @@ use either::Either;
 use indoc::writedoc;
 use serde::Serialize;
 use turbo_rcstr::{RcStr, rcstr};
-use turbo_tasks::{ReadRef, ResolvedVc, TryJoinIterExt, Value, ValueToString, Vc};
+use turbo_tasks::{ReadRef, ResolvedVc, TryJoinIterExt, ValueToString, Vc};
 use turbo_tasks_fs::{File, FileSystemPath, rope::RopeBuilder};
 use turbopack_core::{
     asset::{Asset, AssetContent},
@@ -171,7 +171,7 @@ impl EcmascriptBrowserEvaluateChunk {
                     environment,
                     chunking_context.chunk_base_path(),
                     chunking_context.chunk_suffix_path(),
-                    Value::new(chunking_context.runtime_type()),
+                    chunking_context.runtime_type(),
                     output_root_to_root_path,
                     source_maps,
                 );
@@ -182,7 +182,7 @@ impl EcmascriptBrowserEvaluateChunk {
                     environment,
                     chunking_context.chunk_base_path(),
                     chunking_context.chunk_suffix_path(),
-                    Value::new(chunking_context.runtime_type()),
+                    chunking_context.runtime_type(),
                     output_root_to_root_path,
                     source_maps,
                 );

turbopack/crates/turbopack-browser/src/ecmascript/list/asset.rs

@@ -1,6 +1,7 @@
 use anyhow::Result;
+use serde::{Deserialize, Serialize};
 use turbo_rcstr::{RcStr, rcstr};
-use turbo_tasks::{ResolvedVc, Value, ValueToString, Vc};
+use turbo_tasks::{NonLocalValue, ResolvedVc, TaskInput, ValueToString, Vc, trace::TraceRawVcs};
 use turbo_tasks_fs::FileSystemPath;
 use turbopack_core::{
     asset::{Asset, AssetContent},
@@ -42,14 +43,14 @@ impl EcmascriptDevChunkList {
         ident: ResolvedVc<AssetIdent>,
         evaluatable_assets: ResolvedVc<EvaluatableAssets>,
         chunks: ResolvedVc<OutputAssets>,
-        source: Value<EcmascriptDevChunkListSource>,
+        source: EcmascriptDevChunkListSource,
     ) -> Vc<Self> {
         EcmascriptDevChunkList {
             chunking_context,
             ident,
             evaluatable_assets,
             chunks,
-            source: source.into_value(),
+            source,
         }
         .cell()
     }
@@ -112,8 +113,19 @@ impl Asset for EcmascriptDevChunkList {
     }
 }
 
-#[derive(Debug, Clone, Copy, Hash)]
-#[turbo_tasks::value(serialization = "auto_for_input")]
+#[derive(
+    Eq,
+    PartialEq,
+    Debug,
+    Clone,
+    Copy,
+    Hash,
+    TaskInput,
+    NonLocalValue,
+    TraceRawVcs,
+    Serialize,
+    Deserialize,
+)]
 #[serde(rename_all = "camelCase")]
 pub enum EcmascriptDevChunkListSource {
     /// The chunk list is from a runtime entry.

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

@@ -1,7 +1,7 @@
 use anyhow::Result;
 use serde::{Deserialize, Serialize};
 use turbo_rcstr::RcStr;
-use turbo_tasks::{FxIndexMap, NonLocalValue, ResolvedVc, Vc, trace::TraceRawVcs};
+use turbo_tasks::{FxIndexMap, NonLocalValue, ResolvedVc, TaskInput, Vc, trace::TraceRawVcs};
 use turbo_tasks_fs::FileSystemPath;
 
 use crate::environment::Environment;
@@ -101,8 +101,8 @@ macro_rules! free_var_references {
 
 // TODO: replace with just a `serde_json::Value`
 // https://linear.app/vercel/issue/WEB-1641/compiletimedefinevalue-should-just-use-serde-jsonvalue
-#[turbo_tasks::value(serialization = "auto_for_input")]
-#[derive(Debug, Clone, Hash)]
+#[turbo_tasks::value]
+#[derive(Debug, Clone, Hash, TaskInput)]
 pub enum CompileTimeDefineValue {
     Bool(bool),
     String(RcStr),