Add derive macro for ResolvedValue

.gitattributes

@@ -1,3 +1,4 @@
 .config/ast-grep/rule-tests/__snapshots__/** linguist-generated=true
+crates/turbo-tasks-macros-tests/tests/**/*.stderr linguist-generated=true
 crates/turbopack-tests/tests/snapshot/**/output/** linguist-generated=true
 crates/turborepo-lockfiles/fixtures/*.lock text eol=lf

crates/turbo-tasks-macros-tests/Cargo.toml

@@ -13,6 +13,7 @@ turbo-tasks-memory = { workspace = true }
 turbo-tasks-testing = { workspace = true }
 # TODO: turbo-tasks-testing uses a macro that requires us to depend on lazy-static.
 lazy_static = { workspace = true }
+trybuild = { version = "1.0.97" }
 
 [build-dependencies]
 turbo-tasks-build = { workspace = true }

crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_only_vc.rs

@@ -0,0 +1,10 @@
+#![allow(dead_code)]
+
+use turbo_tasks::{ResolvedValue, Vc};
+
+#[derive(ResolvedValue)]
+struct ContainsOnlyVc {
+ a: Vc<i32>,
+}
+
+fn main() {}

crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_resolved_vc_and_vc.rs

@@ -0,0 +1,11 @@
+#![allow(dead_code)]
+
+use turbo_tasks::{ResolvedValue, ResolvedVc, Vc};
+
+#[derive(ResolvedValue)]
+struct ContainsResolvedVcAndVc {
+ a: ResolvedVc<i32>,
+ b: Vc<i32>,
+}
+
+fn main() {}

crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc_inside_generic.rs

@@ -0,0 +1,10 @@
+#![allow(dead_code)]
+
+use turbo_tasks::{ResolvedValue, Vc};
+
+#[derive(ResolvedValue)]
+struct ContainsVcInsideGeneric {
+ a: Option<Box<[Vc<i32>; 4]>>,
+}
+
+fn main() {}

crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_enum.rs

@@ -0,0 +1,14 @@
+#![allow(dead_code)]
+
+use turbo_tasks::ResolvedValue;
+
+struct UnresolvedValue;
+
+#[derive(ResolvedValue)]
+enum ContainsUnresolvedValue {
+ Unit,
+ Unnamed(UnresolvedValue),
+ Named { a: UnresolvedValue },
+}
+
+fn main() {}

crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_named_struct.rs

@@ -0,0 +1,12 @@
+#![allow(dead_code)]
+
+use turbo_tasks::ResolvedValue;
+
+struct UnresolvedValue;
+
+#[derive(ResolvedValue)]
+struct ContainsUnresolvedValueNamed {
+ a: UnresolvedValue,
+}
+
+fn main() {}

crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_unnamed_struct.rs

@@ -0,0 +1,10 @@
+#![allow(dead_code)]
+
+use turbo_tasks::ResolvedValue;
+
+struct UnresolvedValue;
+
+#[derive(ResolvedValue)]
+struct ContainsUnresolvedValueUnnamed(UnresolvedValue);
+
+fn main() {}

crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_underconstrained_generic.rs

@@ -0,0 +1,10 @@
+#![allow(dead_code)]
+
+use turbo_tasks::ResolvedValue;
+
+#[derive(ResolvedValue)]
+struct ContainsUnderconstrainedGeneric<T> {
+ value: T,
+}
+
+fn main() {}

crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_contains_resolved_vc.rs

@@ -0,0 +1,27 @@
+#![allow(dead_code)]
+
+use turbo_tasks::{ResolvedValue, ResolvedVc};
+
+#[derive(ResolvedValue)]
+struct ContainsResolvedVcNamedStruct {
+ a: ResolvedVc<i32>,
+}
+
+#[derive(ResolvedValue)]
+struct ContainsResolvedVcUnnamedStruct(ResolvedVc<i32>);
+
+#[derive(ResolvedValue)]
+enum ContainsResolvedVcEnum {
+ Unit,
+ Unnamed(ResolvedVc<i32>),
+ Named { a: ResolvedVc<i32> },
+}
+
+#[derive(ResolvedValue)]
+struct ContainsResolvedAlongWithOtherValues {
+ a: i32,
+ b: ResolvedVc<i32>,
+ c: (),
+}
+
+fn main() {}

crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_lifetimes.rs

@@ -0,0 +1,13 @@
+use turbo_tasks::ResolvedValue;
+
+#[derive(ResolvedValue)]
+struct ContainsBorrowedData<'a> {
+ borrowed: &'a Option<&'a [&'a str]>,
+}
+
+fn main() {
+ let a = ContainsBorrowedData {
+ borrowed: &Some(["value"].as_slice()),
+ };
+ let _ = a.borrowed;
+}

crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_linked_list.rs

@@ -0,0 +1,31 @@
+use turbo_tasks::ResolvedValue;
+
+#[derive(ResolvedValue)]
+// use an inline type constraint here
+struct LinkedList<T: ResolvedValue> {
+ // LinkedListNode is also a ResolvedValue
+ head: Option<Box<LinkedListNode<T>>>,
+}
+
+#[derive(ResolvedValue)]
+struct LinkedListNode<T>
+where
+ T: ResolvedValue, // use a where type constraint here
+{
+ current: T,
+ // A self-recursive type
+ next: Option<Box<LinkedListNode<T>>>,
+}
+
+fn main() {
+ let ll = LinkedList {
+ head: Some(Box::new(LinkedListNode {
+ current: 1,
+ next: Some(Box::new(LinkedListNode {
+ current: 2,
+ next: None,
+ })),
+ })),
+ };
+ let _last = ll.head.unwrap().next.unwrap().current;
+}