Create a minimum viable ResolvedVc type (vercel/turborepo#8661)

### Description

We want a way to more strongly guarantee that a `Vc` is resolved for the sake of "local" tasks.

This introduces it in a low-risk way with zero breaking changes. Eventually, we'd want to eliminate `.resolve()` or make `.resolve()` return `ResolvedVc` instead of using a separate `.to_resolved()` method.

Some rough notes about why here: https://www.notion.so/vercel/Resolved-Vcs-Vc-Lifetimes-Local-Vcs-and-Vc-Refcounts-49d666d3f9594017b5b312b87ddc5bff

### Testing Instructions

Tested as a part of vercel/turborepo#8678

crates/turbo-tasks/src/lib.rs

@@ -107,9 +107,9 @@ pub use turbo_tasks_macros::{function, value, value_impl, value_trait, TaskInput
 pub use value::{TransientInstance, TransientValue, Value};
 pub use value_type::{TraitMethod, TraitType, ValueType};
 pub use vc::{
- Dynamic, TypedForInput, Upcast, ValueDefault, Vc, VcCast, VcCellNewMode, VcCellSharedMode,
- VcDefaultRead, VcRead, VcTransparentRead, VcValueTrait, VcValueTraitCast, VcValueType,
- VcValueTypeCast,
+ Dynamic, ResolvedVc, TypedForInput, Upcast, ValueDefault, Vc, VcCast, VcCellNewMode,
+ VcCellSharedMode, VcDefaultRead, VcRead, VcTransparentRead, VcValueTrait, VcValueTraitCast,
+ VcValueType, VcValueTypeCast,
 };
 
 pub use crate::rcstr::RcStr;

crates/turbo-tasks/src/vc/mod.rs

@@ -2,9 +2,15 @@ pub(crate) mod cast;
 mod cell_mode;
 pub(crate) mod default;
 mod read;
+pub(crate) mod resolved;
 mod traits;
 
-use std::{any::Any, marker::PhantomData, ops::Deref};
+use std::{
+ any::Any,
+ hash::{Hash, Hasher},
+ marker::PhantomData,
+ ops::Deref,
+};
 
 use anyhow::Result;
 use auto_hash_map::AutoSet;
@@ -16,6 +22,7 @@ pub use self::{
  cell_mode::{VcCellNewMode, VcCellSharedMode},
  default::ValueDefault,
  read::{ReadVcFuture, VcDefaultRead, VcRead, VcTransparentRead},
+ resolved::ResolvedVc,
  traits::{Dynamic, TypedForInput, Upcast, VcValueTrait, VcValueType},
 };
 use crate::{
@@ -205,11 +212,11 @@ where
  }
 }
 
-impl<T> core::hash::Hash for Vc<T>
+impl<T> Hash for Vc<T>
 where
  T: ?Sized + Send,
 {
- fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+ fn hash<H: Hasher>(&self, state: &mut H) {
  self.node.hash(state);
  }
 }
@@ -363,13 +370,22 @@ where
  ///
  /// This is async and will rethrow any fatal error that happened during task
  /// execution.
- pub async fn resolve(self) -> Result<Self> {
+ pub async fn resolve(self) -> Result<Vc<T>> {
  Ok(Self {
  node: self.node.resolve().await?,
  _t: PhantomData,
  })
  }
 
+ /// Resolve the reference until it points to a cell directly, and wrap the
+ /// result in a [`ResolvedVc`], which strongly guarantees that the
+ /// [`Vc`] was resolved.
+ pub async fn to_resolved(self) -> Result<ResolvedVc<T>> {
+ Ok(ResolvedVc {
+ node: self.resolve().await?,
+ })
+ }
+
  /// Resolve the reference until it points to a cell directly in a strongly
  /// consistent way.
  ///

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

@@ -0,0 +1,34 @@
+use std::{
+ hash::{Hash, Hasher},
+ ops::Deref,
+};
+
+use crate::vc::Vc;
+
+#[derive(Copy, Clone)]
+pub struct ResolvedVc<T>
+where
+ T: ?Sized + Send,
+{
+ pub(crate) node: Vc<T>,
+}
+
+impl<T> Deref for ResolvedVc<T>
+where
+ T: ?Sized + Send,
+{
+ type Target = Vc<T>;
+
+ fn deref(&self) -> &Self::Target {
+ &self.node
+ }
+}
+
+impl<T> Hash for ResolvedVc<T>
+where
+ T: ?Sized + Send,
+{
+ fn hash<H: Hasher>(&self, state: &mut H) {
+ self.node.hash(state);
+ }
+}