perf(turbopack): Use ResolvedVc for turbopack-dev-server

turbopack/crates/turbopack-cli/src/dev/mod.rs

@@ -14,7 +14,7 @@ use owo_colors::OwoColorize;
 use turbo_rcstr::RcStr;
 use turbo_tasks::{
     util::{FormatBytes, FormatDuration},
-    TransientInstance, TurboTasks, UpdateInfo, Value, Vc,
+    ResolvedVc, TransientInstance, TurboTasks, UpdateInfo, Value, Vc,
 };
 use turbo_tasks_fs::FileSystem;
 use turbo_tasks_malloc::TurboMalloc;
@@ -301,23 +301,28 @@ async fn source(
         eager_compile,
         NodeEnv::Development.cell(),
         browserslist_query,
+    )
+    .to_resolved()
+    .await?;
+    let static_source = ResolvedVc::upcast(
+        StaticAssetsContentSource::new(Default::default(), project_path.join("public".into()))
+            .to_resolved()
+            .await?,
     );
-    let static_source = Vc::upcast(StaticAssetsContentSource::new(
-        Default::default(),
-        project_path.join("public".into()),
-    ));
-    let main_source = CombinedContentSource::new(vec![static_source, web_source]);
-    let introspect = Vc::upcast(
+    let main_source = CombinedContentSource::new(vec![static_source, web_source])
+        .to_resolved()
+        .await?;
+    let introspect = ResolvedVc::upcast(
         IntrospectionSource {
-            roots: HashSet::from([Vc::upcast(main_source)]),
+            roots: HashSet::from([ResolvedVc::upcast(main_source)]),
         }
-        .cell(),
+        .resolved_cell(),
     );
-    let main_source = Vc::upcast(main_source);
+    let main_source = ResolvedVc::upcast(main_source);
     Ok(Vc::upcast(PrefixedRouterContentSource::new(
         Default::default(),
         vec![("__turbopack__".into(), introspect)],
-        main_source,
+        *main_source,
     )))
 }
 

turbopack/crates/turbopack-cli/src/dev/web_entry_source.rs

@@ -157,7 +157,7 @@ pub async fn create_web_entry_source(
         .await?;
 
     let entry_asset = Vc::upcast(DevHtmlAsset::new(
-        server_root.join("index.html".into()),
+        server_root.join("index.html".into()).to_resolved().await?,
         entries,
     ));
 

turbopack/crates/turbopack-dev-server/src/html.rs

@@ -30,7 +30,7 @@ type DevHtmlEntry = (
 #[turbo_tasks::value(shared)]
 #[derive(Clone)]
 pub struct DevHtmlAsset {
-    path: Vc<FileSystemPath>,
+    path: ResolvedVc<FileSystemPath>,
     entries: Vec<DevHtmlEntry>,
     body: Option<RcStr>,
 }
@@ -44,7 +44,7 @@ fn dev_html_chunk_reference_description() -> Vc<RcStr> {
 impl OutputAsset for DevHtmlAsset {
     #[turbo_tasks::function]
     fn ident(&self) -> Vc<AssetIdent> {
-        AssetIdent::from_path(self.path)
+        AssetIdent::from_path(*self.path)
     }
 
     #[turbo_tasks::function]
@@ -68,7 +68,7 @@ impl Asset for DevHtmlAsset {
 
 impl DevHtmlAsset {
     /// Create a new dev HTML asset.
-    pub fn new(path: Vc<FileSystemPath>, entries: Vec<DevHtmlEntry>) -> Vc<Self> {
+    pub fn new(path: ResolvedVc<FileSystemPath>, entries: Vec<DevHtmlEntry>) -> Vc<Self> {
         DevHtmlAsset {
             path,
             entries,
@@ -79,7 +79,7 @@ impl DevHtmlAsset {
 
     /// Create a new dev HTML asset.
     pub fn new_with_body(
-        path: Vc<FileSystemPath>,
+        path: ResolvedVc<FileSystemPath>,
         entries: Vec<DevHtmlEntry>,
         body: RcStr,
     ) -> Vc<Self> {
@@ -95,7 +95,7 @@ impl DevHtmlAsset {
 #[turbo_tasks::value_impl]
 impl DevHtmlAsset {
     #[turbo_tasks::function]
-    pub async fn with_path(self: Vc<Self>, path: Vc<FileSystemPath>) -> Result<Vc<Self>> {
+    pub async fn with_path(self: Vc<Self>, path: ResolvedVc<FileSystemPath>) -> Result<Vc<Self>> {
         let mut html: DevHtmlAsset = self.await?.clone_value();
         html.path = path;
         Ok(html.cell())

turbopack/crates/turbopack-dev-server/src/introspect/mod.rs

@@ -2,7 +2,7 @@ use std::{borrow::Cow, collections::HashSet, fmt::Display};
 
 use anyhow::Result;
 use turbo_rcstr::RcStr;
-use turbo_tasks::{ReadRef, TryJoinIterExt, Vc};
+use turbo_tasks::{ReadRef, ResolvedVc, TryJoinIterExt, Vc};
 use turbo_tasks_fs::{json::parse_json_with_source_context, File};
 use turbopack_core::{
     asset::AssetContent,
@@ -18,7 +18,7 @@ use crate::source::{
 
 #[turbo_tasks::value(shared)]
 pub struct IntrospectionSource {
-    pub roots: HashSet<Vc<Box<dyn Introspectable>>>,
+    pub roots: HashSet<ResolvedVc<Box<dyn Introspectable>>>,
 }
 
 #[turbo_tasks::value_impl]
@@ -36,7 +36,7 @@ impl Introspectable for IntrospectionSource {
     #[turbo_tasks::function]
     fn children(&self) -> Vc<IntrospectableChildren> {
         let name = Vc::cell("root".into());
-        Vc::cell(self.roots.iter().map(|root| (name, *root)).collect())
+        Vc::cell(self.roots.iter().map(|root| (name, **root)).collect())
     }
 }
 
@@ -76,20 +76,24 @@ impl<T: Display> Display for HtmlStringEscaped<T> {
 #[turbo_tasks::value_impl]
 impl ContentSource for IntrospectionSource {
     #[turbo_tasks::function]
-    fn get_routes(self: Vc<Self>) -> Vc<RouteTree> {
-        Vc::<RouteTrees>::cell(vec![
-            RouteTree::new_route(Vec::new(), RouteType::Exact, Vc::upcast(self)),
-            RouteTree::new_route(Vec::new(), RouteType::CatchAll, Vc::upcast(self)),
+    async fn get_routes(self: Vc<Self>) -> Result<Vc<RouteTree>> {
+        Ok(Vc::<RouteTrees>::cell(vec![
+            RouteTree::new_route(Vec::new(), RouteType::Exact, Vc::upcast(self))
+                .to_resolved()
+                .await?,
+            RouteTree::new_route(Vec::new(), RouteType::CatchAll, Vc::upcast(self))
+                .to_resolved()
+                .await?,
         ])
-        .merge()
+        .merge())
     }
 }
 
 #[turbo_tasks::value_impl]
 impl GetContentSourceContent for IntrospectionSource {
     #[turbo_tasks::function]
     async fn get(
-        self: Vc<Self>,
+        self: ResolvedVc<Self>,
         path: RcStr,
         _data: turbo_tasks::Value<ContentSourceData>,
     ) -> Result<Vc<ContentSourceContent>> {
@@ -100,12 +104,12 @@ impl GetContentSourceContent for IntrospectionSource {
             if roots.len() == 1 {
                 *roots.iter().next().unwrap()
             } else {
-                Vc::upcast(self)
+                ResolvedVc::upcast(self)
             }
         } else {
             parse_json_with_source_context(path)?
         };
-        let internal_ty = Vc::debug_identifier(introspectable).await?;
+        let internal_ty = Vc::debug_identifier(*introspectable).await?;
         fn str_or_err(s: &Result<ReadRef<RcStr>>) -> Cow<'_, str> {
             s.as_ref().map_or_else(
                 |e| Cow::<'_, str>::Owned(format!("ERROR: {:?}", e)),

turbopack/crates/turbopack-dev-server/src/source/asset_graph.rs

@@ -29,8 +29,8 @@ type ExpandedState = State<HashSet<RcStr>>;
 
 #[turbo_tasks::value(serialization = "none", eq = "manual", cell = "new")]
 pub struct AssetGraphContentSource {
-    root_path: Vc<FileSystemPath>,
-    root_assets: Vc<OutputAssetsSet>,
+    root_path: ResolvedVc<FileSystemPath>,
+    root_assets: ResolvedVc<OutputAssetsSet>,
     expanded: Option<ExpandedState>,
 }
 
@@ -39,12 +39,12 @@ impl AssetGraphContentSource {
     /// Serves all assets references by root_asset.
     #[turbo_tasks::function]
     pub fn new_eager(
-        root_path: Vc<FileSystemPath>,
+        root_path: ResolvedVc<FileSystemPath>,
         root_asset: ResolvedVc<Box<dyn OutputAsset>>,
     ) -> Vc<Self> {
         Self::cell(AssetGraphContentSource {
             root_path,
-            root_assets: Vc::cell(fxindexset! { root_asset }),
+            root_assets: ResolvedVc::cell(fxindexset! { root_asset }),
             expanded: None,
         })
     }
@@ -53,21 +53,21 @@ impl AssetGraphContentSource {
     /// asset when it has served its content before.
     #[turbo_tasks::function]
     pub fn new_lazy(
-        root_path: Vc<FileSystemPath>,
+        root_path: ResolvedVc<FileSystemPath>,
         root_asset: ResolvedVc<Box<dyn OutputAsset>>,
     ) -> Vc<Self> {
         Self::cell(AssetGraphContentSource {
             root_path,
-            root_assets: Vc::cell(fxindexset! { root_asset }),
+            root_assets: ResolvedVc::cell(fxindexset! { root_asset }),
             expanded: Some(State::new(HashSet::new())),
         })
     }
 
     /// Serves all assets references by all root_assets.
     #[turbo_tasks::function]
     pub fn new_eager_multiple(
-        root_path: Vc<FileSystemPath>,
-        root_assets: Vc<OutputAssetsSet>,
+        root_path: ResolvedVc<FileSystemPath>,
+        root_assets: ResolvedVc<OutputAssetsSet>,
     ) -> Vc<Self> {
         Self::cell(AssetGraphContentSource {
             root_path,
@@ -80,8 +80,8 @@ impl AssetGraphContentSource {
     /// of an asset when it has served its content before.
     #[turbo_tasks::function]
     pub fn new_lazy_multiple(
-        root_path: Vc<FileSystemPath>,
-        root_assets: Vc<OutputAssetsSet>,
+        root_path: ResolvedVc<FileSystemPath>,
+        root_assets: ResolvedVc<OutputAssetsSet>,
     ) -> Vc<Self> {
         Self::cell(AssetGraphContentSource {
             root_path,
@@ -230,25 +230,27 @@ impl ContentSource for AssetGraphContentSource {
                     )),
                 )
             })
-            .collect();
+            .map(|v| async move { v.to_resolved().await })
+            .try_join()
+            .await?;
         Ok(Vc::<RouteTrees>::cell(routes).merge())
     }
 }
 
 #[turbo_tasks::value]
 struct AssetGraphGetContentSourceContent {
-    source: Vc<AssetGraphContentSource>,
+    source: ResolvedVc<AssetGraphContentSource>,
     path: RcStr,
-    asset: Vc<Box<dyn OutputAsset>>,
+    asset: ResolvedVc<Box<dyn OutputAsset>>,
 }
 
 #[turbo_tasks::value_impl]
 impl AssetGraphGetContentSourceContent {
     #[turbo_tasks::function]
     pub fn new(
-        source: Vc<AssetGraphContentSource>,
+        source: ResolvedVc<AssetGraphContentSource>,
         path: RcStr,
-        asset: Vc<Box<dyn OutputAsset>>,
+        asset: ResolvedVc<Box<dyn OutputAsset>>,
     ) -> Vc<Self> {
         Self::cell(AssetGraphGetContentSourceContent {
             source,

turbopack/crates/turbopack-dev-server/src/source/combined.rs

@@ -1,6 +1,6 @@
 use anyhow::Result;
 use turbo_rcstr::RcStr;
-use turbo_tasks::{TryJoinIterExt, Vc};
+use turbo_tasks::{ResolvedVc, TryJoinIterExt, Vc};
 use turbopack_core::introspect::{Introspectable, IntrospectableChildren};
 
 use super::{
@@ -15,21 +15,26 @@ use crate::source::ContentSources;
 /// not a [ContentSourceContent::NotFound]) will be returned.
 #[turbo_tasks::value(shared)]
 pub struct CombinedContentSource {
-    pub sources: Vec<Vc<Box<dyn ContentSource>>>,
+    pub sources: Vec<ResolvedVc<Box<dyn ContentSource>>>,
 }
 
 impl CombinedContentSource {
-    pub fn new(sources: Vec<Vc<Box<dyn ContentSource>>>) -> Vc<Self> {
+    pub fn new(sources: Vec<ResolvedVc<Box<dyn ContentSource>>>) -> Vc<Self> {
         CombinedContentSource { sources }.cell()
     }
 }
 
 #[turbo_tasks::value_impl]
 impl ContentSource for CombinedContentSource {
     #[turbo_tasks::function]
-    fn get_routes(&self) -> Vc<RouteTree> {
-        let all_routes = self.sources.iter().map(|s| s.get_routes()).collect();
-        Vc::<RouteTrees>::cell(all_routes).merge()
+    async fn get_routes(&self) -> Result<Vc<RouteTree>> {
+        let all_routes = self
+            .sources
+            .iter()
+            .map(|s| async move { s.get_routes().to_resolved().await })
+            .try_join()
+            .await?;
+        Ok(Vc::<RouteTrees>::cell(all_routes).merge())
     }
 
     #[turbo_tasks::function]
@@ -53,7 +58,7 @@ impl Introspectable for CombinedContentSource {
             .map(|&source| async move {
                 Ok(
                     if let Some(source) =
-                        Vc::try_resolve_sidecast::<Box<dyn Introspectable>>(source).await?
+                        ResolvedVc::try_sidecast::<Box<dyn Introspectable>>(source).await?
                     {
                         Some(source.title().await?)
                     } else {
@@ -86,13 +91,13 @@ impl Introspectable for CombinedContentSource {
                 .iter()
                 .copied()
                 .map(|s| async move {
-                    Ok(Vc::try_resolve_sidecast::<Box<dyn Introspectable>>(s).await?)
+                    Ok(ResolvedVc::try_sidecast::<Box<dyn Introspectable>>(s).await?)
                 })
                 .try_join()
                 .await?
                 .into_iter()
                 .flatten()
-                .map(|i| (source, i))
+                .map(|i| (source, *i))
                 .collect(),
         ))
     }