Manual fixes

Cargo.toml

@@ -6,7 +6,6 @@ members = [
   "crates/turbo-tasks*",
   "crates/turbopack*",
   "crates/turborepo*",
-  "crates/turbo-tasks-vc-test",
   "xtask",
 ]
 
@@ -28,7 +27,6 @@ default-members = [
   "crates/turbo-tasks-signposter-sys",
   "crates/turbo-tasks-testing",
   "crates/turbo-tasks-tracing-signpost",
-  "crates/turbo-tasks-vc-test",
   "crates/turbopack",
   "crates/turbopack-bench",
   "crates/turbopack-cli-utils",

crates/node-file-trace/src/lib.rs

@@ -1,4 +1,6 @@
 #![feature(min_specialization)]
+#![feature(arbitrary_self_types)]
+#![feature(async_fn_in_trait)]
 
 mod nft_json;
 
@@ -22,7 +24,7 @@ use serde::Deserialize;
 use serde::Serialize;
 use tokio::sync::mpsc::channel;
 use turbo_tasks::{
-    backend::Backend, util::FormatDuration, Nothing, TaskId, TransientInstance, TransientValue,
+    backend::Backend, unit, util::FormatDuration, TaskId, TransientInstance, TransientValue,
     TurboTasks, TurboTasksBackendApi, UpdateInfo, Value, Vc,
 };
 use turbo_tasks_fs::{
@@ -34,8 +36,7 @@ use turbo_tasks_memory::{
 };
 use turbopack::{
     emit_asset, emit_with_completion, module_options::ModuleOptionsContext, rebase::RebasedAsset,
-    resolve_options_context::ResolveOptionsContext, transition::TransitionsByName,
-    ModuleAssetContext,
+    resolve_options_context::ResolveOptionsContext, ModuleAssetContext,
 };
 use turbopack_cli_utils::issue::{ConsoleUi, IssueSeverityCliOption, LogOptions};
 use turbopack_core::{
@@ -44,7 +45,7 @@ use turbopack_core::{
     context::AssetContext,
     environment::{Environment, ExecutionEnvironment, NodeJsEnvironment},
     file_source::FileSource,
-    issue::{Issue, IssueContextExt, IssueReporter, IssueSeverity},
+    issue::{IssueContextExt, IssueReporter, IssueSeverity},
     reference::all_assets,
     resolve::options::{ImportMapping, ResolvedMap},
 };
@@ -200,7 +201,7 @@ async fn create_fs(name: &str, context: &str, watch: bool) -> Result<Vc<Box<dyn
     } else {
         fs.await?.invalidate();
     }
-    Ok(fs.into())
+    Ok(Vc::upcast(fs))
 }
 
 async fn add_glob_results(
@@ -212,14 +213,10 @@ async fn add_glob_results(
     for entry in result.results.values() {
         if let DirectoryEntry::File(path) = entry {
             let source = Vc::upcast(FileSource::new(*path));
-            list.push(
-                context
-                    .process(
-                        source,
-                        Value::new(turbopack_core::reference_type::ReferenceType::Undefined),
-                    )
-                    .into(),
-            );
+            list.push(Vc::upcast(context.process(
+                source,
+                Value::new(turbopack_core::reference_type::ReferenceType::Undefined),
+            )));
         }
     }
     for result in result.inner.values() {
@@ -237,7 +234,7 @@ async fn add_glob_results(
 }
 
 #[turbo_tasks::function]
-async fn input_to_modules<'a>(
+async fn input_to_modules(
     fs: Vc<Box<dyn FileSystem>>,
     input: Vec<String>,
     exact: bool,
@@ -251,21 +248,25 @@ async fn input_to_modules<'a>(
         .clone()
         .map(|p| p.trim_start_matches(&context).to_owned());
 
-    let context: Vc<Box<dyn AssetContext>> =
-        create_module_asset(root, process_cwd, module_options, resolve_options).into();
+    let context: Vc<Box<dyn AssetContext>> = Vc::upcast(create_module_asset(
+        root,
+        process_cwd,
+        module_options,
+        resolve_options,
+    ));
 
     let mut list = Vec::new();
-    for input in input.iter() {
+    for input in input {
         if exact {
             let source = Vc::upcast(FileSource::new(root.join(input)));
-            list.push(
+            list.push(Vc::upcast(
                 context
                     .process(
                         source,
                         Value::new(turbopack_core::reference_type::ReferenceType::Undefined),
                     )
                     .into(),
-            );
+            ));
         } else {
             let glob = Glob::new(input);
             add_glob_results(context, root.read_glob(glob, false), &mut list).await?;
@@ -498,14 +499,15 @@ async fn run<B: Backend + 'static, F: Future<Output = ()>>(
                 resolve_options,
             );
 
-            let source = TransientValue::new(output.into());
-            let issues = Issue::peek_issues_with_path(output)
+            let source = TransientValue::new(output.node);
+            let issues = output
+                .peek_issues_with_path()
                 .await?
                 .strongly_consistent()
                 .await?;
 
             let console_ui = ConsoleUi::new(log_options);
-            Vc::upcast(console_ui)
+            Vc::upcast::<Box<dyn IssueReporter>>(console_ui)
                 .report_issues(TransientInstance::new(issues), source)
                 .await?;
 
@@ -515,7 +517,7 @@ async fn run<B: Backend + 'static, F: Future<Output = ()>>(
                 sender.send(output_iter.collect::<Vec<String>>()).await?;
                 drop(sender);
             }
-            Ok(Nothing::new().into())
+            Ok(unit().node)
         })
     });
     finish(tt, task).await?;
@@ -592,7 +594,7 @@ async fn main_operation(
                 let nft_asset = NftJsonAsset::new(*module);
                 let path = nft_asset.ident().path().await?.path.clone();
                 output_nft_assets.push(path);
-                emits.push(emit_asset(nft_asset.into()));
+                emits.push(emit_asset(Vc::upcast(nft_asset)));
             }
             // Wait for all files to be emitted
             for emit in emits {
@@ -653,12 +655,12 @@ async fn create_module_asset(
     let glob_mappings = vec![
         (
             root,
-            Glob::new("**/*/next/dist/server/next.js"),
+            Glob::new("**/*/next/dist/server/next.js".to_string()),
             ImportMapping::Ignore.into(),
         ),
         (
             root,
-            Glob::new("**/*/next/dist/bin/next"),
+            Glob::new("**/*/next/dist/bin/next".to_string()),
             ImportMapping::Ignore.into(),
         ),
     ];

crates/node-file-trace/src/nft_json.rs

@@ -31,7 +31,7 @@ impl Asset for NftJsonAsset {
     async fn ident(&self) -> Result<Vc<AssetIdent>> {
         let path = self.entry.ident().path().await?;
         Ok(AssetIdent::from_path(
-            path.fs.root().join(&format!("{}.nft.json", path.path)),
+            path.fs.root().join(format!("{}.nft.json", path.path)),
         ))
     }
 
@@ -59,6 +59,6 @@ impl Asset for NftJsonAsset {
           "files": result
         });
 
-        Ok(File::from(json.to_string()).into())
+        Ok(AssetContent::file(File::from(json.to_string()).into()))
     }
 }

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

@@ -228,7 +228,7 @@ impl<'a> RegisterContext<'a> {
 
     fn process_impl(&mut self, impl_item: ItemImpl) -> Result<()> {
         if has_attribute(&impl_item.attrs, "value_impl") {
-            let struct_ident = get_type_ident(&*impl_item.self_ty).unwrap();
+            let struct_ident = get_type_ident(&impl_item.self_ty).unwrap();
 
             let trait_ident = impl_item
                 .trait_

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

@@ -1,8 +1,9 @@
+#![feature(arbitrary_self_types)]
+#![feature(async_fn_in_trait)]
+
 pub mod bytes;
 pub mod stream;
 
-use turbo_tasks::Vc;
-
 pub use crate::{
     bytes::Bytes,
     stream::{Stream, StreamRead},

crates/turbo-tasks-env/src/custom.rs

@@ -33,7 +33,7 @@ impl ProcessEnv for CustomProcessEnv {
 
     #[turbo_tasks::function]
     async fn read(&self, name: String) -> Result<Vc<Option<String>>> {
-        let custom = case_insensitive_read(self.custom, name);
+        let custom = case_insensitive_read(self.custom, name.clone());
         match &*custom.await? {
             Some(_) => Ok(custom),
             None => Ok(self.prior.read(name)),

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

@@ -1,4 +1,5 @@
-#![feature(min_specialization)]
+#![feature(arbitrary_self_types)]
+#![feature(async_fn_in_trait)]
 
 mod command_line;
 mod custom;
@@ -51,7 +52,7 @@ pub trait ProcessEnv {
     fn read_all(self: Vc<Self>) -> Vc<EnvMap>;
 
     /// Reads a single env variable. Ignores casing.
-    fn read(self: Vc<Self>, name: &str) -> Vc<Option<String>> {
+    fn read(self: Vc<Self>, name: String) -> Vc<Option<String>> {
         case_insensitive_read(self.read_all(), name)
     }
 }

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

@@ -1,4 +1,6 @@
 #![feature(min_specialization)]
+#![feature(arbitrary_self_types)]
+#![feature(async_fn_in_trait)]
 
 use anyhow::Result;
 use turbo_tasks::Vc;

crates/turbo-tasks-fetch/tests/fetch.rs

@@ -142,9 +142,5 @@ async fn errors_on_404() {
 }
 
 fn get_issue_context() -> Vc<FileSystemPath> {
-    std::convert::Into::<Vc<Box<dyn FileSystem>>>::into(DiskFileSystem::new(
-        "root".to_owned(),
-        "/".to_owned(),
-    ))
-    .root()
+    DiskFileSystem::new("root".to_owned(), "/".to_owned()).root()
 }

crates/turbo-tasks-fs/examples/hash_directory.rs

@@ -1,5 +1,4 @@
 #![feature(trivial_bounds)]
-#![feature(min_specialization)]
 
 use std::{
     collections::BTreeMap,
@@ -10,7 +9,7 @@ use std::{
 
 use anyhow::Result;
 use sha2::{Digest, Sha256};
-use turbo_tasks::{util::FormatDuration, Nothing, TurboTasks, UpdateInfo, Vc};
+use turbo_tasks::{unit, util::FormatDuration, TurboTasks, UpdateInfo, Vc};
 use turbo_tasks_fs::{
     register, DirectoryContent, DirectoryEntry, DiskFileSystem, FileContent, FileSystem,
     FileSystemPath,
@@ -35,11 +34,11 @@ async fn main() -> Result<()> {
             disk_fs.await?.start_watching()?;
 
             // Smart Pointer cast
-            let fs: Vc<Box<dyn FileSystem>> = disk_fs.into();
-            let input = fs.root().join("demo");
+            let fs: Vc<Box<dyn FileSystem>> = Vc::upcast(disk_fs);
+            let input = fs.root().join("demo".to_string());
             let dir_hash = hash_directory(input);
             print_hash(dir_hash).await?;
-            Ok(Nothing::new().into())
+            Ok(unit().node)
         })
     });
     tt.wait_task_completion(task, true).await.unwrap();

crates/turbo-tasks-fs/examples/hash_glob.rs

@@ -1,5 +1,4 @@
 #![feature(trivial_bounds)]
-#![feature(min_specialization)]
 
 use std::{
     collections::BTreeMap,
@@ -10,7 +9,7 @@ use std::{
 
 use anyhow::Result;
 use sha2::{Digest, Sha256};
-use turbo_tasks::{util::FormatDuration, Nothing, TurboTasks, UpdateInfo, Vc};
+use turbo_tasks::{unit, util::FormatDuration, TurboTasks, UpdateInfo, Vc};
 use turbo_tasks_fs::{
     glob::Glob, register, DirectoryEntry, DiskFileSystem, FileContent, FileSystem, FileSystemPath,
     ReadGlobResult,
@@ -32,13 +31,13 @@ async fn main() -> Result<()> {
             disk_fs.await?.start_watching()?;
 
             // Smart Pointer cast
-            let fs: Vc<Box<dyn FileSystem>> = disk_fs.into();
-            let input = fs.root().join("crates");
-            let glob = Glob::new("**/*.rs");
+            let fs: Vc<Box<dyn FileSystem>> = Vc::upcast(disk_fs);
+            let input = fs.root().join("crates".to_string());
+            let glob = Glob::new("**/*.rs".to_string());
             let glob_result = input.read_glob(glob, true);
             let dir_hash = hash_glob_result(glob_result);
             print_hash(dir_hash).await?;
-            Ok(Nothing::new().into())
+            Ok(unit().node)
         })
     });
     tt.wait_task_completion(task, true).await.unwrap();