refactor(turbo-tasks): Add a way to directly construct a ResolvedVc

turbopack/crates/turbo-tasks-macros/src/value_macro.rs

@@ -317,6 +317,15 @@ pub fn value(args: TokenStream, input: TokenStream) -> TokenStream {
             turbo_tasks::Vc::cell_private(#cell_access_content)
         }
 
+        /// Places a value in a cell of the current task. Returns a
+        /// [`ResolvedVc`][turbo_tasks::ResolvedVc].
+        ///
+        /// Cell is selected based on the value type and call order of `cell`.
+        #cell_prefix fn resolved_cell(self) -> turbo_tasks::ResolvedVc<Self> {
+            let content = self;
+            turbo_tasks::ResolvedVc::cell_private(#cell_access_content)
+        }
+
         /// Places a value in a task-local cell stored in the current task.
         ///
         /// Task-local cells are stored in a task-local arena, and do not persist outside the

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

@@ -6,6 +6,9 @@ use turbo_tasks_testing::{register, run, Registration};
 
 static REGISTRATION: Registration = register!();
 
+#[turbo_tasks::value]
+struct Wrapper(u32);
+
 #[tokio::test]
 async fn test_conversion() -> Result<()> {
     run(&REGISTRATION, || async {
@@ -20,3 +23,15 @@ async fn test_conversion() -> Result<()> {
     })
     .await
 }
+
+#[tokio::test]
+async fn test_cell_construction() -> Result<()> {
+    run(&REGISTRATION, || async {
+        let a: ResolvedVc<u32> = ResolvedVc::cell(42);
+        assert_eq!(*a.await?, 42);
+        let b: ResolvedVc<Wrapper> = Wrapper(42).resolved_cell();
+        assert_eq!(b.await?.0, 42);
+        Ok(())
+    })
+    .await
+}

turbopack/crates/turbo-tasks/src/vc/resolved.rs

@@ -1,4 +1,5 @@
 use std::{
+    any::Any,
     cell::RefCell,
     collections::{BTreeMap, BTreeSet, HashMap, HashSet},
     future::IntoFuture,
@@ -23,7 +24,7 @@ use serde::{Deserialize, Serialize};
 use crate::{
     trace::{TraceRawVcs, TraceRawVcsContext},
     vc::Vc,
-    RcStr, VcValueType,
+    RcStr, VcRead, VcTransparentRead, VcValueType,
 };
 
 #[derive(Serialize, Deserialize)]
@@ -95,6 +96,32 @@ macro_rules! into_future {
 into_future!(ResolvedVc<T>);
 into_future!(&ResolvedVc<T>);
 
+impl<T> ResolvedVc<T>
+where
+    T: VcValueType,
+{
+    // called by the `.resolved_cell()` method generated by the `#[turbo_tasks::value]` macro
+    #[doc(hidden)]
+    pub fn cell_private(inner: <T::Read as VcRead<T>>::Target) -> Self {
+        Self {
+            node: Vc::<T>::cell_private(inner),
+        }
+    }
+}
+
+impl<T, Inner, Repr> ResolvedVc<T>
+where
+    T: VcValueType<Read = VcTransparentRead<T, Inner, Repr>>,
+    Inner: Any + Send + Sync,
+    Repr: VcValueType,
+{
+    pub fn cell(inner: Inner) -> Self {
+        Self {
+            node: Vc::<T>::cell(inner),
+        }
+    }
+}
+
 impl<T> std::fmt::Debug for ResolvedVc<T>
 where
     T: Send,