From 3021db78068cc28639be03c5979242075d0ba90f Mon Sep 17 00:00:00 2001 From: Benjamin Woodruff Date: Fri, 5 Jul 2024 14:45:01 -0700 Subject: [PATCH 1/6] Add derive macro for ResolvedValue --- Cargo.lock | 1 + .../tests/derive_resolved_value.rs | 17 +++++++ crates/turbo-tasks-macros/Cargo.toml | 1 + crates/turbo-tasks-macros/src/derive/mod.rs | 2 + .../src/derive/resolved_value_macro.rs | 50 +++++++++++++++++++ crates/turbo-tasks-macros/src/lib.rs | 5 ++ crates/turbo-tasks/src/vc/resolved.rs | 2 + 7 files changed, 78 insertions(+) create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value.rs create mode 100644 crates/turbo-tasks-macros/src/derive/resolved_value_macro.rs diff --git a/Cargo.lock b/Cargo.lock index dff4502909952..823597585b7e6 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -10261,6 +10261,7 @@ name = "turbo-tasks-macros" version = "0.1.0" dependencies = [ "anyhow", + "either", "proc-macro-error", "proc-macro2", "quote", diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value.rs new file mode 100644 index 0000000000000..401162c105fb9 --- /dev/null +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value.rs @@ -0,0 +1,17 @@ +use turbo_tasks::{ResolvedValue, ResolvedVc, Vc}; + +#[derive(ResolvedValue)] +struct ContainsResolvedVc { + a: ResolvedVc, +} + +#[derive(ResolvedValue)] +struct ContainsVc { + a: Vc, +} + +#[derive(ResolvedValue)] +struct ContainsMixedVc { + a: Vc, + b: ResolvedVc, +} diff --git a/crates/turbo-tasks-macros/Cargo.toml b/crates/turbo-tasks-macros/Cargo.toml index 9d6509310a716..0200335e03ce2 100644 --- a/crates/turbo-tasks-macros/Cargo.toml +++ b/crates/turbo-tasks-macros/Cargo.toml @@ -14,6 +14,7 @@ workspace = true [dependencies] anyhow = { workspace = true } +either = { workspace = true } proc-macro-error = "1.0.4" proc-macro2 = { workspace = true } quote = { workspace = true } diff --git a/crates/turbo-tasks-macros/src/derive/mod.rs b/crates/turbo-tasks-macros/src/derive/mod.rs index 953fc350c8e02..d48323309096e 100644 --- a/crates/turbo-tasks-macros/src/derive/mod.rs +++ b/crates/turbo-tasks-macros/src/derive/mod.rs @@ -1,10 +1,12 @@ mod deterministic_hash_macro; +mod resolved_value_macro; mod task_input_macro; mod trace_raw_vcs_macro; mod value_debug_format_macro; mod value_debug_macro; pub use deterministic_hash_macro::derive_deterministic_hash; +pub use resolved_value_macro::derive_resolved_value; use syn::{spanned::Spanned, Attribute, Meta, MetaList, NestedMeta}; pub use task_input_macro::derive_task_input; pub use trace_raw_vcs_macro::derive_trace_raw_vcs; diff --git a/crates/turbo-tasks-macros/src/derive/resolved_value_macro.rs b/crates/turbo-tasks-macros/src/derive/resolved_value_macro.rs new file mode 100644 index 0000000000000..0b44a48afd025 --- /dev/null +++ b/crates/turbo-tasks-macros/src/derive/resolved_value_macro.rs @@ -0,0 +1,50 @@ +use either::Either; +use proc_macro::TokenStream; +use proc_macro2::TokenStream as TokenStream2; +use quote::{quote, quote_spanned}; +use syn::{parse_macro_input, spanned::Spanned, Data, DeriveInput, Generics, Type}; + +pub fn derive_resolved_value(input: TokenStream) -> TokenStream { + let derive_input = parse_macro_input!(input as DeriveInput); + let ident = &derive_input.ident; + + let assertions: Vec<_> = iter_data_fields(&derive_input.data) + .map(|f| assert_field_resolved_value(&derive_input.generics, &f.ty)) + .collect(); + + let (impl_generics, ty_generics, where_clause) = derive_input.generics.split_for_impl(); + quote! { + unsafe impl #impl_generics ::turbo_tasks::ResolvedValue + for #ident #ty_generics #where_clause {} + #(#assertions)* + } + .into() +} + +fn iter_data_fields(data: &Data) -> impl Iterator { + match data { + Data::Struct(ds) => Either::Left(ds.fields.iter()), + Data::Enum(de) => Either::Right(Either::Left(de.variants.iter().flat_map(|v| &v.fields))), + Data::Union(du) => Either::Right(Either::Right(du.fields.named.iter())), + } +} + +fn assert_field_resolved_value(generics: &Generics, ty: &Type) -> TokenStream2 { + // this technique is based on the trick used by + // `static_assertions::assert_impl_all`, but extended to support generics. + let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); + quote_spanned! { + ty.span() => + const _: fn() = || { + // create this struct just to hold onto our generics + struct StaticAssertion #impl_generics #where_clause; + impl #impl_generics StaticAssertion #ty_generics #where_clause { + fn assert_impl_resolved_value() {} + fn call_site() { + // this call is only valid if ty is a ResolvedValue + Self::assert_impl_resolved_value::<#ty>(); + } + } + }; + } +} diff --git a/crates/turbo-tasks-macros/src/lib.rs b/crates/turbo-tasks-macros/src/lib.rs index f9977e5afd1c4..c1ced476b8e28 100644 --- a/crates/turbo-tasks-macros/src/lib.rs +++ b/crates/turbo-tasks-macros/src/lib.rs @@ -22,6 +22,11 @@ pub fn derive_trace_raw_vcs_attr(input: TokenStream) -> TokenStream { derive::derive_trace_raw_vcs(input) } +#[proc_macro_derive(ResolvedValue, attributes(turbo_tasks))] +pub fn derive_resolved_value_attr(input: TokenStream) -> TokenStream { + derive::derive_resolved_value(input) +} + #[proc_macro_derive(ValueDebug, attributes(turbo_tasks))] pub fn derive_value_debug_attr(input: TokenStream) -> TokenStream { derive::derive_value_debug(input) diff --git a/crates/turbo-tasks/src/vc/resolved.rs b/crates/turbo-tasks/src/vc/resolved.rs index ec29ec4e0bec4..7a80758d48640 100644 --- a/crates/turbo-tasks/src/vc/resolved.rs +++ b/crates/turbo-tasks/src/vc/resolved.rs @@ -128,3 +128,5 @@ unsafe impl ResolvedValue for PhantomData {} unsafe impl ResolvedValue for &T {} unsafe impl ResolvedValue for &mut T {} + +pub use turbo_tasks_macros::ResolvedValue; From f33da56a9cfd16faae44389b3a65f80990f508b1 Mon Sep 17 00:00:00 2001 From: Benjamin Woodruff Date: Mon, 8 Jul 2024 13:30:21 -0700 Subject: [PATCH 2/6] Add trybuild --- Cargo.lock | 15 +++++++++++ crates/turbo-tasks-macros-tests/Cargo.toml | 1 + .../tests/derive_resolved_value.rs | 17 ------------ .../pass-contains-resolved-vc.rs | 26 +++++++++++++++++++ .../pass-simple-structs.rs | 23 ++++++++++++++++ .../tests/trybuild.rs | 6 +++++ 6 files changed, 71 insertions(+), 17 deletions(-) delete mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value.rs create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass-contains-resolved-vc.rs create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass-simple-structs.rs create mode 100644 crates/turbo-tasks-macros-tests/tests/trybuild.rs diff --git a/Cargo.lock b/Cargo.lock index 823597585b7e6..751f368b6e991 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -10027,6 +10027,20 @@ version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed" +[[package]] +name = "trybuild" +version = "1.0.97" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b1e5645f2ee8025c2f1d75e1138f2dd034d74e6ba54620f3c569ba2a2a1ea06" +dependencies = [ + "glob", + "serde", + "serde_derive", + "serde_json", + "termcolor", + "toml 0.8.14", +] + [[package]] name = "ttf-parser" version = "0.15.2" @@ -10286,6 +10300,7 @@ dependencies = [ "anyhow", "lazy_static", "tokio", + "trybuild", "turbo-tasks", "turbo-tasks-build", "turbo-tasks-memory", diff --git a/crates/turbo-tasks-macros-tests/Cargo.toml b/crates/turbo-tasks-macros-tests/Cargo.toml index f68df867b1846..5080fc64bf1b6 100644 --- a/crates/turbo-tasks-macros-tests/Cargo.toml +++ b/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 } diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value.rs deleted file mode 100644 index 401162c105fb9..0000000000000 --- a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value.rs +++ /dev/null @@ -1,17 +0,0 @@ -use turbo_tasks::{ResolvedValue, ResolvedVc, Vc}; - -#[derive(ResolvedValue)] -struct ContainsResolvedVc { - a: ResolvedVc, -} - -#[derive(ResolvedValue)] -struct ContainsVc { - a: Vc, -} - -#[derive(ResolvedValue)] -struct ContainsMixedVc { - a: Vc, - b: ResolvedVc, -} diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass-contains-resolved-vc.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass-contains-resolved-vc.rs new file mode 100644 index 0000000000000..a182c6c83012f --- /dev/null +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass-contains-resolved-vc.rs @@ -0,0 +1,26 @@ +#![allow(dead_code)] + +use turbo_tasks::{ResolvedValue, ResolvedVc}; + +#[derive(ResolvedValue)] +struct ContainsResolvedVcNamedStruct { + a: ResolvedVc, +} + +#[derive(ResolvedValue)] +struct ContainsResolvedVcUnnamedStruct(ResolvedVc); + +#[derive(ResolvedValue)] +enum ContainsResolvedVcEnum { + Unnamed(ResolvedVc), + Named { a: ResolvedVc }, +} + +#[derive(ResolvedValue)] +struct ContainsResolvedAlongWithOtherValues { + a: i32, + b: ResolvedVc, + c: (), +} + +fn main() {} diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass-simple-structs.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass-simple-structs.rs new file mode 100644 index 0000000000000..1d7420d65a072 --- /dev/null +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass-simple-structs.rs @@ -0,0 +1,23 @@ +#![allow(dead_code)] + +use std::marker::PhantomData; + +use turbo_tasks::ResolvedValue; + +#[derive(ResolvedValue)] +struct UnitStruct; + +#[derive(ResolvedValue)] +struct ContainsSimpleValuesNamed { + a: i32, + b: String, + c: (), + d: (u8, u8, (u8, u8, u8)), + e: [u8; 8], + f: PhantomData, +} + +#[derive(ResolvedValue)] +struct ContainsSimpleValuesUnnamed(i32, String, ()); + +fn main() {} diff --git a/crates/turbo-tasks-macros-tests/tests/trybuild.rs b/crates/turbo-tasks-macros-tests/tests/trybuild.rs new file mode 100644 index 0000000000000..c1633c42012f7 --- /dev/null +++ b/crates/turbo-tasks-macros-tests/tests/trybuild.rs @@ -0,0 +1,6 @@ +#[test] +fn derive_resolved_value() { + let t = trybuild::TestCases::new(); + t.pass("tests/derive_resolved_value/pass-*.rs"); + t.compile_fail("tests/derive_resolved_value/fail-*.rs"); +} From 07e85b773188734f8ab7c5b22c13dc80fb57616d Mon Sep 17 00:00:00 2001 From: Benjamin Woodruff Date: Mon, 8 Jul 2024 15:58:31 -0700 Subject: [PATCH 3/6] Add more tests, reduce size of generated code, fix some generics issues --- .gitattributes | 1 + .../fail_simple_structs.rs | 15 +++++++ .../fail_simple_structs.stderr | 45 +++++++++++++++++++ ...ved-vc.rs => pass_contains_resolved_vc.rs} | 1 + .../derive_resolved_value/pass_linked_list.rs | 30 +++++++++++++ .../pass_simple_enums.rs | 19 ++++++++ ...mple-structs.rs => pass_simple_structs.rs} | 0 .../tests/trybuild.rs | 4 +- .../src/derive/resolved_value_macro.rs | 35 +++++++++------ 9 files changed, 134 insertions(+), 16 deletions(-) create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_structs.rs create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_structs.stderr rename crates/turbo-tasks-macros-tests/tests/derive_resolved_value/{pass-contains-resolved-vc.rs => pass_contains_resolved_vc.rs} (98%) create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_linked_list.rs create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_simple_enums.rs rename crates/turbo-tasks-macros-tests/tests/derive_resolved_value/{pass-simple-structs.rs => pass_simple_structs.rs} (100%) diff --git a/.gitattributes b/.gitattributes index bd24553281a47..650dc002a59d5 100644 --- a/.gitattributes +++ b/.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 diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_structs.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_structs.rs new file mode 100644 index 0000000000000..ce147daf2150c --- /dev/null +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_structs.rs @@ -0,0 +1,15 @@ +#![allow(dead_code)] + +use turbo_tasks::ResolvedValue; + +struct UnresolvedValue; + +#[derive(ResolvedValue)] +struct ContainsUnresolvedValueNamed { + a: UnresolvedValue, +} + +#[derive(ResolvedValue)] +struct ContainsUnresolvedValueUnnamed(UnresolvedValue); + +fn main() {} diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_structs.stderr b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_structs.stderr new file mode 100644 index 0000000000000..8414b4d4984cd --- /dev/null +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_structs.stderr @@ -0,0 +1,45 @@ +error[E0277]: the trait bound `UnresolvedValue: ResolvedValue` is not satisfied + --> tests/derive_resolved_value/fail_simple_structs.rs:9:8 + | +9 | a: UnresolvedValue, + | ^^^^^^^^^^^^^^^ the trait `ResolvedValue` is not implemented for `UnresolvedValue` + | + = help: the following other types implement trait `ResolvedValue`: + &str + () + (A, Z, Y, X, W, V, U, T) + (B, A, Z, Y, X, W, V, U, T) + (C, B, A, Z, Y, X, W, V, U, T) + (D, C, B, A, Z, Y, X, W, V, U, T) + (E, D, C, B, A, Z, Y, X, W, V, U, T) + (T,) + and $N others +note: required by a bound in `_::{closure#0}::DeriveResolvedValueAssertion::assert_impl_resolved_value` + --> tests/derive_resolved_value/fail_simple_structs.rs:7:10 + | +7 | #[derive(ResolvedValue)] + | ^^^^^^^^^^^^^ required by this bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` + = note: this error originates in the derive macro `ResolvedValue` (in Nightly builds, run with -Z macro-backtrace for more info) + +error[E0277]: the trait bound `UnresolvedValue: ResolvedValue` is not satisfied + --> tests/derive_resolved_value/fail_simple_structs.rs:13:39 + | +13 | struct ContainsUnresolvedValueUnnamed(UnresolvedValue); + | ^^^^^^^^^^^^^^^ the trait `ResolvedValue` is not implemented for `UnresolvedValue` + | + = help: the following other types implement trait `ResolvedValue`: + &str + () + (A, Z, Y, X, W, V, U, T) + (B, A, Z, Y, X, W, V, U, T) + (C, B, A, Z, Y, X, W, V, U, T) + (D, C, B, A, Z, Y, X, W, V, U, T) + (E, D, C, B, A, Z, Y, X, W, V, U, T) + (T,) + and $N others +note: required by a bound in `_::{closure#0}::DeriveResolvedValueAssertion::assert_impl_resolved_value` + --> tests/derive_resolved_value/fail_simple_structs.rs:12:10 + | +12 | #[derive(ResolvedValue)] + | ^^^^^^^^^^^^^ required by this bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` + = note: this error originates in the derive macro `ResolvedValue` (in Nightly builds, run with -Z macro-backtrace for more info) diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass-contains-resolved-vc.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_contains_resolved_vc.rs similarity index 98% rename from crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass-contains-resolved-vc.rs rename to crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_contains_resolved_vc.rs index a182c6c83012f..5c80368183097 100644 --- a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass-contains-resolved-vc.rs +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_contains_resolved_vc.rs @@ -12,6 +12,7 @@ struct ContainsResolvedVcUnnamedStruct(ResolvedVc); #[derive(ResolvedValue)] enum ContainsResolvedVcEnum { + Unit, Unnamed(ResolvedVc), Named { a: ResolvedVc }, } diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_linked_list.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_linked_list.rs new file mode 100644 index 0000000000000..418f24d4f15e6 --- /dev/null +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_linked_list.rs @@ -0,0 +1,30 @@ +use turbo_tasks::ResolvedValue; + +#[derive(ResolvedValue)] +// use an inline type constraint here +struct LinkedList { + // LinkedListNode is also a ResolvedValue + head: Option>>, +} + +#[derive(ResolvedValue)] +struct LinkedListNode +where + T: ResolvedValue, // use a where type constraint here +{ + current: T, + // A self-recursive type + next: Option>>, +} + +fn main() { + let _ll = LinkedList { + head: Some(Box::new(LinkedListNode { + current: 1, + next: Some(Box::new(LinkedListNode { + current: 2, + next: None, + })), + })), + }; +} diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_simple_enums.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_simple_enums.rs new file mode 100644 index 0000000000000..46c1ce3d9d75e --- /dev/null +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_simple_enums.rs @@ -0,0 +1,19 @@ +#![allow(dead_code)] + +use turbo_tasks::{ResolvedValue, ResolvedVc}; + +#[derive(ResolvedValue)] +enum EnumI32 { + Unit, + Unnamed(i32), + Named { a: i32 }, +} + +#[derive(ResolvedValue)] +enum EnumResolvedVc { + Unit, + Unnamed(ResolvedVc), + Named { a: ResolvedVc }, +} + +fn main() {} diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass-simple-structs.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_simple_structs.rs similarity index 100% rename from crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass-simple-structs.rs rename to crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_simple_structs.rs diff --git a/crates/turbo-tasks-macros-tests/tests/trybuild.rs b/crates/turbo-tasks-macros-tests/tests/trybuild.rs index c1633c42012f7..749369094b88e 100644 --- a/crates/turbo-tasks-macros-tests/tests/trybuild.rs +++ b/crates/turbo-tasks-macros-tests/tests/trybuild.rs @@ -1,6 +1,6 @@ #[test] fn derive_resolved_value() { let t = trybuild::TestCases::new(); - t.pass("tests/derive_resolved_value/pass-*.rs"); - t.compile_fail("tests/derive_resolved_value/fail-*.rs"); + t.pass("tests/derive_resolved_value/pass_*.rs"); + t.compile_fail("tests/derive_resolved_value/fail_*.rs"); } diff --git a/crates/turbo-tasks-macros/src/derive/resolved_value_macro.rs b/crates/turbo-tasks-macros/src/derive/resolved_value_macro.rs index 0b44a48afd025..86ce9dca298fa 100644 --- a/crates/turbo-tasks-macros/src/derive/resolved_value_macro.rs +++ b/crates/turbo-tasks-macros/src/derive/resolved_value_macro.rs @@ -2,21 +2,19 @@ use either::Either; use proc_macro::TokenStream; use proc_macro2::TokenStream as TokenStream2; use quote::{quote, quote_spanned}; -use syn::{parse_macro_input, spanned::Spanned, Data, DeriveInput, Generics, Type}; +use syn::{parse_macro_input, spanned::Spanned, Data, DeriveInput, Generics}; pub fn derive_resolved_value(input: TokenStream) -> TokenStream { let derive_input = parse_macro_input!(input as DeriveInput); let ident = &derive_input.ident; - let assertions: Vec<_> = iter_data_fields(&derive_input.data) - .map(|f| assert_field_resolved_value(&derive_input.generics, &f.ty)) - .collect(); + let assertions = assert_fields_impl_resolved_value(&derive_input.generics, &derive_input.data); let (impl_generics, ty_generics, where_clause) = derive_input.generics.split_for_impl(); quote! { unsafe impl #impl_generics ::turbo_tasks::ResolvedValue for #ident #ty_generics #where_clause {} - #(#assertions)* + #assertions } .into() } @@ -29,20 +27,29 @@ fn iter_data_fields(data: &Data) -> impl Iterator { } } -fn assert_field_resolved_value(generics: &Generics, ty: &Type) -> TokenStream2 { +fn assert_fields_impl_resolved_value(generics: &Generics, data: &Data) -> TokenStream2 { // this technique is based on the trick used by // `static_assertions::assert_impl_all`, but extended to support generics. let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); - quote_spanned! { - ty.span() => + let field_types: Vec<_> = iter_data_fields(data).map(|field| &field.ty).collect(); + let assertion_calls = field_types.iter().map(|ty| { + quote_spanned! { + // attribute type assertion errors to the line where the field is defined + ty.span() => + // this call is only valid if ty is a ResolvedValue + Self::assert_impl_resolved_value::<#ty>(); + } + }); + quote! { const _: fn() = || { - // create this struct just to hold onto our generics - struct StaticAssertion #impl_generics #where_clause; - impl #impl_generics StaticAssertion #ty_generics #where_clause { + // create this struct just to hold onto our generics... + // we reproduce the field types here to ensure any generics get used + struct DeriveResolvedValueAssertion #impl_generics (#(#field_types),*) #where_clause; + + impl #impl_generics DeriveResolvedValueAssertion #ty_generics #where_clause { fn assert_impl_resolved_value() {} - fn call_site() { - // this call is only valid if ty is a ResolvedValue - Self::assert_impl_resolved_value::<#ty>(); + fn field_types() { + #(#assertion_calls)* } } }; From 16857f4bc3a3a1d5d1e67e422c7e0a32e1a8ac02 Mon Sep 17 00:00:00 2001 From: Benjamin Woodruff Date: Mon, 8 Jul 2024 16:22:38 -0700 Subject: [PATCH 4/6] More tests --- .../derive_resolved_value/fail_contains_vc.rs | 21 ++++++ .../fail_contains_vc.stderr | 71 +++++++++++++++++++ .../derive_resolved_value/pass_lifetimes.rs | 11 +++ .../derive_resolved_value/pass_linked_list.rs | 3 +- .../pass_phantom_data.rs | 16 +++++ 5 files changed, 121 insertions(+), 1 deletion(-) create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc.rs create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc.stderr create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_lifetimes.rs create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_phantom_data.rs diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc.rs new file mode 100644 index 0000000000000..6e6f7bbdf9af6 --- /dev/null +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc.rs @@ -0,0 +1,21 @@ +#![allow(dead_code)] + +use turbo_tasks::{ResolvedValue, ResolvedVc, Vc}; + +#[derive(ResolvedValue)] +struct ContainsOnlyVc { + a: Vc, +} + +#[derive(ResolvedValue)] +struct ContainsResolvedVcAndVc { + a: ResolvedVc, + b: Vc, +} + +#[derive(ResolvedValue)] +struct ContainsVcInsideGeneric { + a: Option; 4]>>, +} + +fn main() {} diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc.stderr b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc.stderr new file mode 100644 index 0000000000000..a4584ef24440b --- /dev/null +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc.stderr @@ -0,0 +1,71 @@ +error[E0277]: the trait bound `Vc: ResolvedValue` is not satisfied + --> tests/derive_resolved_value/fail_contains_vc.rs:13:8 + | +13 | b: Vc, + | ^^^^^^^ the trait `ResolvedValue` is not implemented for `Vc` + | + = help: the following other types implement trait `ResolvedValue`: + &str + () + (A, Z, Y, X, W, V, U, T) + (B, A, Z, Y, X, W, V, U, T) + (C, B, A, Z, Y, X, W, V, U, T) + (D, C, B, A, Z, Y, X, W, V, U, T) + (E, D, C, B, A, Z, Y, X, W, V, U, T) + (T,) + and $N others +note: required by a bound in `_::{closure#0}::DeriveResolvedValueAssertion::assert_impl_resolved_value` + --> tests/derive_resolved_value/fail_contains_vc.rs:10:10 + | +10 | #[derive(ResolvedValue)] + | ^^^^^^^^^^^^^ required by this bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` + = note: this error originates in the derive macro `ResolvedValue` (in Nightly builds, run with -Z macro-backtrace for more info) + +error[E0277]: the trait bound `Vc: ResolvedValue` is not satisfied + --> tests/derive_resolved_value/fail_contains_vc.rs:7:8 + | +7 | a: Vc, + | ^^^^^^^ the trait `ResolvedValue` is not implemented for `Vc` + | + = help: the following other types implement trait `ResolvedValue`: + &str + () + (A, Z, Y, X, W, V, U, T) + (B, A, Z, Y, X, W, V, U, T) + (C, B, A, Z, Y, X, W, V, U, T) + (D, C, B, A, Z, Y, X, W, V, U, T) + (E, D, C, B, A, Z, Y, X, W, V, U, T) + (T,) + and $N others +note: required by a bound in `_::{closure#0}::DeriveResolvedValueAssertion::assert_impl_resolved_value` + --> tests/derive_resolved_value/fail_contains_vc.rs:5:10 + | +5 | #[derive(ResolvedValue)] + | ^^^^^^^^^^^^^ required by this bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` + = note: this error originates in the derive macro `ResolvedValue` (in Nightly builds, run with -Z macro-backtrace for more info) + +error[E0277]: the trait bound `Vc: ResolvedValue` is not satisfied + --> tests/derive_resolved_value/fail_contains_vc.rs:18:8 + | +18 | a: Option; 4]>>, + | ^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `ResolvedValue` is not implemented for `Vc`, which is required by `Option; 4]>>: ResolvedValue` + | + = help: the following other types implement trait `ResolvedValue`: + &str + () + (A, Z, Y, X, W, V, U, T) + (B, A, Z, Y, X, W, V, U, T) + (C, B, A, Z, Y, X, W, V, U, T) + (D, C, B, A, Z, Y, X, W, V, U, T) + (E, D, C, B, A, Z, Y, X, W, V, U, T) + (T,) + and $N others + = note: required for `[Vc; 4]` to implement `ResolvedValue` + = note: 2 redundant requirements hidden + = note: required for `Option; 4]>>` to implement `ResolvedValue` +note: required by a bound in `_::{closure#0}::DeriveResolvedValueAssertion::assert_impl_resolved_value` + --> tests/derive_resolved_value/fail_contains_vc.rs:16:10 + | +16 | #[derive(ResolvedValue)] + | ^^^^^^^^^^^^^ required by this bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` + = note: this error originates in the derive macro `ResolvedValue` (in Nightly builds, run with -Z macro-backtrace for more info) diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_lifetimes.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_lifetimes.rs new file mode 100644 index 0000000000000..ebe6e678f1392 --- /dev/null +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_lifetimes.rs @@ -0,0 +1,11 @@ +use turbo_tasks::ResolvedValue; + +#[derive(ResolvedValue)] +struct ContainsBorrowedData<'a> { + borrowed: &'a str, +} + +fn main() { + let a = ContainsBorrowedData { borrowed: "value" }; + let _ = a.borrowed; +} diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_linked_list.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_linked_list.rs index 418f24d4f15e6..f57c0e06225cb 100644 --- a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_linked_list.rs +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_linked_list.rs @@ -18,7 +18,7 @@ where } fn main() { - let _ll = LinkedList { + let ll = LinkedList { head: Some(Box::new(LinkedListNode { current: 1, next: Some(Box::new(LinkedListNode { @@ -27,4 +27,5 @@ fn main() { })), })), }; + let _last = ll.head.unwrap().next.unwrap().current; } diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_phantom_data.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_phantom_data.rs new file mode 100644 index 0000000000000..b6e540a5efb59 --- /dev/null +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_phantom_data.rs @@ -0,0 +1,16 @@ +#![allow(dead_code)] + +use std::marker::PhantomData; + +use turbo_tasks::{ResolvedValue, Vc}; + +struct Unresolved; + +#[derive(ResolvedValue)] +struct PhantomDataCanContainAnything( + PhantomData>, + PhantomData, + PhantomData>, +); + +fn main() {} From 3af0f86ed2dec2adb829748f43f6e92599626c62 Mon Sep 17 00:00:00 2001 From: Benjamin Woodruff Date: Mon, 8 Jul 2024 16:55:17 -0700 Subject: [PATCH 5/6] Split failing tests Error ordering was non-deterministic. One error per file should mitigate this. --- .../fail_contains_only_vc.rs | 10 +++ .../fail_contains_only_vc.stderr | 22 ++++++ ...rs => fail_contains_resolved_vc_and_vc.rs} | 10 --- .../fail_contains_resolved_vc_and_vc.stderr | 22 ++++++ .../fail_contains_vc.stderr | 71 ------------------- .../fail_contains_vc_inside_generic.rs | 10 +++ .../fail_contains_vc_inside_generic.stderr | 25 +++++++ ...structs.rs => fail_simple_named_struct.rs} | 3 - .../fail_simple_named_struct.stderr | 22 ++++++ .../fail_simple_structs.stderr | 45 ------------ .../fail_simple_unnamed_struct.rs | 10 +++ .../fail_simple_unnamed_struct.stderr | 22 ++++++ 12 files changed, 143 insertions(+), 129 deletions(-) create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_only_vc.rs create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_only_vc.stderr rename crates/turbo-tasks-macros-tests/tests/derive_resolved_value/{fail_contains_vc.rs => fail_contains_resolved_vc_and_vc.rs} (53%) create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_resolved_vc_and_vc.stderr delete mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc.stderr create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc_inside_generic.rs create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc_inside_generic.stderr rename crates/turbo-tasks-macros-tests/tests/derive_resolved_value/{fail_simple_structs.rs => fail_simple_named_struct.rs} (69%) create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_named_struct.stderr delete mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_structs.stderr create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_unnamed_struct.rs create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_unnamed_struct.stderr diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_only_vc.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_only_vc.rs new file mode 100644 index 0000000000000..f091233b4f018 --- /dev/null +++ b/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, +} + +fn main() {} diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_only_vc.stderr b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_only_vc.stderr new file mode 100644 index 0000000000000..1f42634d81596 --- /dev/null +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_only_vc.stderr @@ -0,0 +1,22 @@ +error[E0277]: the trait bound `Vc: ResolvedValue` is not satisfied + --> tests/derive_resolved_value/fail_contains_only_vc.rs:7:8 + | +7 | a: Vc, + | ^^^^^^^ the trait `ResolvedValue` is not implemented for `Vc` + | + = help: the following other types implement trait `ResolvedValue`: + &str + () + (A, Z, Y, X, W, V, U, T) + (B, A, Z, Y, X, W, V, U, T) + (C, B, A, Z, Y, X, W, V, U, T) + (D, C, B, A, Z, Y, X, W, V, U, T) + (E, D, C, B, A, Z, Y, X, W, V, U, T) + (T,) + and $N others +note: required by a bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` + --> tests/derive_resolved_value/fail_contains_only_vc.rs:5:10 + | +5 | #[derive(ResolvedValue)] + | ^^^^^^^^^^^^^ required by this bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` + = note: this error originates in the derive macro `ResolvedValue` (in Nightly builds, run with -Z macro-backtrace for more info) diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_resolved_vc_and_vc.rs similarity index 53% rename from crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc.rs rename to crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_resolved_vc_and_vc.rs index 6e6f7bbdf9af6..46f2db572d90d 100644 --- a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc.rs +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_resolved_vc_and_vc.rs @@ -2,20 +2,10 @@ use turbo_tasks::{ResolvedValue, ResolvedVc, Vc}; -#[derive(ResolvedValue)] -struct ContainsOnlyVc { - a: Vc, -} - #[derive(ResolvedValue)] struct ContainsResolvedVcAndVc { a: ResolvedVc, b: Vc, } -#[derive(ResolvedValue)] -struct ContainsVcInsideGeneric { - a: Option; 4]>>, -} - fn main() {} diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_resolved_vc_and_vc.stderr b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_resolved_vc_and_vc.stderr new file mode 100644 index 0000000000000..d4afe91954346 --- /dev/null +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_resolved_vc_and_vc.stderr @@ -0,0 +1,22 @@ +error[E0277]: the trait bound `Vc: ResolvedValue` is not satisfied + --> tests/derive_resolved_value/fail_contains_resolved_vc_and_vc.rs:8:8 + | +8 | b: Vc, + | ^^^^^^^ the trait `ResolvedValue` is not implemented for `Vc` + | + = help: the following other types implement trait `ResolvedValue`: + &str + () + (A, Z, Y, X, W, V, U, T) + (B, A, Z, Y, X, W, V, U, T) + (C, B, A, Z, Y, X, W, V, U, T) + (D, C, B, A, Z, Y, X, W, V, U, T) + (E, D, C, B, A, Z, Y, X, W, V, U, T) + (T,) + and $N others +note: required by a bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` + --> tests/derive_resolved_value/fail_contains_resolved_vc_and_vc.rs:5:10 + | +5 | #[derive(ResolvedValue)] + | ^^^^^^^^^^^^^ required by this bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` + = note: this error originates in the derive macro `ResolvedValue` (in Nightly builds, run with -Z macro-backtrace for more info) diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc.stderr b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc.stderr deleted file mode 100644 index a4584ef24440b..0000000000000 --- a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc.stderr +++ /dev/null @@ -1,71 +0,0 @@ -error[E0277]: the trait bound `Vc: ResolvedValue` is not satisfied - --> tests/derive_resolved_value/fail_contains_vc.rs:13:8 - | -13 | b: Vc, - | ^^^^^^^ the trait `ResolvedValue` is not implemented for `Vc` - | - = help: the following other types implement trait `ResolvedValue`: - &str - () - (A, Z, Y, X, W, V, U, T) - (B, A, Z, Y, X, W, V, U, T) - (C, B, A, Z, Y, X, W, V, U, T) - (D, C, B, A, Z, Y, X, W, V, U, T) - (E, D, C, B, A, Z, Y, X, W, V, U, T) - (T,) - and $N others -note: required by a bound in `_::{closure#0}::DeriveResolvedValueAssertion::assert_impl_resolved_value` - --> tests/derive_resolved_value/fail_contains_vc.rs:10:10 - | -10 | #[derive(ResolvedValue)] - | ^^^^^^^^^^^^^ required by this bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` - = note: this error originates in the derive macro `ResolvedValue` (in Nightly builds, run with -Z macro-backtrace for more info) - -error[E0277]: the trait bound `Vc: ResolvedValue` is not satisfied - --> tests/derive_resolved_value/fail_contains_vc.rs:7:8 - | -7 | a: Vc, - | ^^^^^^^ the trait `ResolvedValue` is not implemented for `Vc` - | - = help: the following other types implement trait `ResolvedValue`: - &str - () - (A, Z, Y, X, W, V, U, T) - (B, A, Z, Y, X, W, V, U, T) - (C, B, A, Z, Y, X, W, V, U, T) - (D, C, B, A, Z, Y, X, W, V, U, T) - (E, D, C, B, A, Z, Y, X, W, V, U, T) - (T,) - and $N others -note: required by a bound in `_::{closure#0}::DeriveResolvedValueAssertion::assert_impl_resolved_value` - --> tests/derive_resolved_value/fail_contains_vc.rs:5:10 - | -5 | #[derive(ResolvedValue)] - | ^^^^^^^^^^^^^ required by this bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` - = note: this error originates in the derive macro `ResolvedValue` (in Nightly builds, run with -Z macro-backtrace for more info) - -error[E0277]: the trait bound `Vc: ResolvedValue` is not satisfied - --> tests/derive_resolved_value/fail_contains_vc.rs:18:8 - | -18 | a: Option; 4]>>, - | ^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `ResolvedValue` is not implemented for `Vc`, which is required by `Option; 4]>>: ResolvedValue` - | - = help: the following other types implement trait `ResolvedValue`: - &str - () - (A, Z, Y, X, W, V, U, T) - (B, A, Z, Y, X, W, V, U, T) - (C, B, A, Z, Y, X, W, V, U, T) - (D, C, B, A, Z, Y, X, W, V, U, T) - (E, D, C, B, A, Z, Y, X, W, V, U, T) - (T,) - and $N others - = note: required for `[Vc; 4]` to implement `ResolvedValue` - = note: 2 redundant requirements hidden - = note: required for `Option; 4]>>` to implement `ResolvedValue` -note: required by a bound in `_::{closure#0}::DeriveResolvedValueAssertion::assert_impl_resolved_value` - --> tests/derive_resolved_value/fail_contains_vc.rs:16:10 - | -16 | #[derive(ResolvedValue)] - | ^^^^^^^^^^^^^ required by this bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` - = note: this error originates in the derive macro `ResolvedValue` (in Nightly builds, run with -Z macro-backtrace for more info) diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc_inside_generic.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc_inside_generic.rs new file mode 100644 index 0000000000000..52e7e833e1ea9 --- /dev/null +++ b/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; 4]>>, +} + +fn main() {} diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc_inside_generic.stderr b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc_inside_generic.stderr new file mode 100644 index 0000000000000..34efba714c418 --- /dev/null +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc_inside_generic.stderr @@ -0,0 +1,25 @@ +error[E0277]: the trait bound `Vc: ResolvedValue` is not satisfied + --> tests/derive_resolved_value/fail_contains_vc_inside_generic.rs:7:8 + | +7 | a: Option; 4]>>, + | ^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `ResolvedValue` is not implemented for `Vc`, which is required by `Option; 4]>>: ResolvedValue` + | + = help: the following other types implement trait `ResolvedValue`: + &str + () + (A, Z, Y, X, W, V, U, T) + (B, A, Z, Y, X, W, V, U, T) + (C, B, A, Z, Y, X, W, V, U, T) + (D, C, B, A, Z, Y, X, W, V, U, T) + (E, D, C, B, A, Z, Y, X, W, V, U, T) + (T,) + and $N others + = note: required for `[Vc; 4]` to implement `ResolvedValue` + = note: 2 redundant requirements hidden + = note: required for `Option; 4]>>` to implement `ResolvedValue` +note: required by a bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` + --> tests/derive_resolved_value/fail_contains_vc_inside_generic.rs:5:10 + | +5 | #[derive(ResolvedValue)] + | ^^^^^^^^^^^^^ required by this bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` + = note: this error originates in the derive macro `ResolvedValue` (in Nightly builds, run with -Z macro-backtrace for more info) diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_structs.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_named_struct.rs similarity index 69% rename from crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_structs.rs rename to crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_named_struct.rs index ce147daf2150c..bd138baba00b2 100644 --- a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_structs.rs +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_named_struct.rs @@ -9,7 +9,4 @@ struct ContainsUnresolvedValueNamed { a: UnresolvedValue, } -#[derive(ResolvedValue)] -struct ContainsUnresolvedValueUnnamed(UnresolvedValue); - fn main() {} diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_named_struct.stderr b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_named_struct.stderr new file mode 100644 index 0000000000000..49cb721a27d06 --- /dev/null +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_named_struct.stderr @@ -0,0 +1,22 @@ +error[E0277]: the trait bound `UnresolvedValue: ResolvedValue` is not satisfied + --> tests/derive_resolved_value/fail_simple_named_struct.rs:9:8 + | +9 | a: UnresolvedValue, + | ^^^^^^^^^^^^^^^ the trait `ResolvedValue` is not implemented for `UnresolvedValue` + | + = help: the following other types implement trait `ResolvedValue`: + &str + () + (A, Z, Y, X, W, V, U, T) + (B, A, Z, Y, X, W, V, U, T) + (C, B, A, Z, Y, X, W, V, U, T) + (D, C, B, A, Z, Y, X, W, V, U, T) + (E, D, C, B, A, Z, Y, X, W, V, U, T) + (T,) + and $N others +note: required by a bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` + --> tests/derive_resolved_value/fail_simple_named_struct.rs:7:10 + | +7 | #[derive(ResolvedValue)] + | ^^^^^^^^^^^^^ required by this bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` + = note: this error originates in the derive macro `ResolvedValue` (in Nightly builds, run with -Z macro-backtrace for more info) diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_structs.stderr b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_structs.stderr deleted file mode 100644 index 8414b4d4984cd..0000000000000 --- a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_structs.stderr +++ /dev/null @@ -1,45 +0,0 @@ -error[E0277]: the trait bound `UnresolvedValue: ResolvedValue` is not satisfied - --> tests/derive_resolved_value/fail_simple_structs.rs:9:8 - | -9 | a: UnresolvedValue, - | ^^^^^^^^^^^^^^^ the trait `ResolvedValue` is not implemented for `UnresolvedValue` - | - = help: the following other types implement trait `ResolvedValue`: - &str - () - (A, Z, Y, X, W, V, U, T) - (B, A, Z, Y, X, W, V, U, T) - (C, B, A, Z, Y, X, W, V, U, T) - (D, C, B, A, Z, Y, X, W, V, U, T) - (E, D, C, B, A, Z, Y, X, W, V, U, T) - (T,) - and $N others -note: required by a bound in `_::{closure#0}::DeriveResolvedValueAssertion::assert_impl_resolved_value` - --> tests/derive_resolved_value/fail_simple_structs.rs:7:10 - | -7 | #[derive(ResolvedValue)] - | ^^^^^^^^^^^^^ required by this bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` - = note: this error originates in the derive macro `ResolvedValue` (in Nightly builds, run with -Z macro-backtrace for more info) - -error[E0277]: the trait bound `UnresolvedValue: ResolvedValue` is not satisfied - --> tests/derive_resolved_value/fail_simple_structs.rs:13:39 - | -13 | struct ContainsUnresolvedValueUnnamed(UnresolvedValue); - | ^^^^^^^^^^^^^^^ the trait `ResolvedValue` is not implemented for `UnresolvedValue` - | - = help: the following other types implement trait `ResolvedValue`: - &str - () - (A, Z, Y, X, W, V, U, T) - (B, A, Z, Y, X, W, V, U, T) - (C, B, A, Z, Y, X, W, V, U, T) - (D, C, B, A, Z, Y, X, W, V, U, T) - (E, D, C, B, A, Z, Y, X, W, V, U, T) - (T,) - and $N others -note: required by a bound in `_::{closure#0}::DeriveResolvedValueAssertion::assert_impl_resolved_value` - --> tests/derive_resolved_value/fail_simple_structs.rs:12:10 - | -12 | #[derive(ResolvedValue)] - | ^^^^^^^^^^^^^ required by this bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` - = note: this error originates in the derive macro `ResolvedValue` (in Nightly builds, run with -Z macro-backtrace for more info) diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_unnamed_struct.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_unnamed_struct.rs new file mode 100644 index 0000000000000..5549af87f1f86 --- /dev/null +++ b/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() {} diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_unnamed_struct.stderr b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_unnamed_struct.stderr new file mode 100644 index 0000000000000..f779b92423904 --- /dev/null +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_unnamed_struct.stderr @@ -0,0 +1,22 @@ +error[E0277]: the trait bound `UnresolvedValue: ResolvedValue` is not satisfied + --> tests/derive_resolved_value/fail_simple_unnamed_struct.rs:8:39 + | +8 | struct ContainsUnresolvedValueUnnamed(UnresolvedValue); + | ^^^^^^^^^^^^^^^ the trait `ResolvedValue` is not implemented for `UnresolvedValue` + | + = help: the following other types implement trait `ResolvedValue`: + &str + () + (A, Z, Y, X, W, V, U, T) + (B, A, Z, Y, X, W, V, U, T) + (C, B, A, Z, Y, X, W, V, U, T) + (D, C, B, A, Z, Y, X, W, V, U, T) + (E, D, C, B, A, Z, Y, X, W, V, U, T) + (T,) + and $N others +note: required by a bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` + --> tests/derive_resolved_value/fail_simple_unnamed_struct.rs:7:10 + | +7 | #[derive(ResolvedValue)] + | ^^^^^^^^^^^^^ required by this bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` + = note: this error originates in the derive macro `ResolvedValue` (in Nightly builds, run with -Z macro-backtrace for more info) From 04de3a9d5a402c82923b28f0d1d9a3a123ca6f45 Mon Sep 17 00:00:00 2001 From: Benjamin Woodruff Date: Mon, 8 Jul 2024 17:09:21 -0700 Subject: [PATCH 6/6] More tests --- .../fail_contains_only_vc.stderr | 4 +- .../fail_contains_resolved_vc_and_vc.stderr | 4 +- .../fail_contains_vc_inside_generic.stderr | 4 +- .../derive_resolved_value/fail_simple_enum.rs | 14 ++++++ .../fail_simple_enum.stderr | 45 +++++++++++++++++++ .../fail_simple_named_struct.stderr | 4 +- .../fail_simple_unnamed_struct.stderr | 4 +- .../fail_underconstrained_generic.rs | 10 +++++ .../fail_underconstrained_generic.stderr | 16 +++++++ .../derive_resolved_value/pass_lifetimes.rs | 6 ++- 10 files changed, 99 insertions(+), 12 deletions(-) create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_enum.rs create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_enum.stderr create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_underconstrained_generic.rs create mode 100644 crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_underconstrained_generic.stderr diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_only_vc.stderr b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_only_vc.stderr index 1f42634d81596..32b9d09452a35 100644 --- a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_only_vc.stderr +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_only_vc.stderr @@ -5,14 +5,14 @@ error[E0277]: the trait bound `Vc: ResolvedValue` is not satisfied | ^^^^^^^ the trait `ResolvedValue` is not implemented for `Vc` | = help: the following other types implement trait `ResolvedValue`: - &str + &T + &mut T () (A, Z, Y, X, W, V, U, T) (B, A, Z, Y, X, W, V, U, T) (C, B, A, Z, Y, X, W, V, U, T) (D, C, B, A, Z, Y, X, W, V, U, T) (E, D, C, B, A, Z, Y, X, W, V, U, T) - (T,) and $N others note: required by a bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` --> tests/derive_resolved_value/fail_contains_only_vc.rs:5:10 diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_resolved_vc_and_vc.stderr b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_resolved_vc_and_vc.stderr index d4afe91954346..3c6098cdc5fed 100644 --- a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_resolved_vc_and_vc.stderr +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_resolved_vc_and_vc.stderr @@ -5,14 +5,14 @@ error[E0277]: the trait bound `Vc: ResolvedValue` is not satisfied | ^^^^^^^ the trait `ResolvedValue` is not implemented for `Vc` | = help: the following other types implement trait `ResolvedValue`: - &str + &T + &mut T () (A, Z, Y, X, W, V, U, T) (B, A, Z, Y, X, W, V, U, T) (C, B, A, Z, Y, X, W, V, U, T) (D, C, B, A, Z, Y, X, W, V, U, T) (E, D, C, B, A, Z, Y, X, W, V, U, T) - (T,) and $N others note: required by a bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` --> tests/derive_resolved_value/fail_contains_resolved_vc_and_vc.rs:5:10 diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc_inside_generic.stderr b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc_inside_generic.stderr index 34efba714c418..dc91f11ada319 100644 --- a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc_inside_generic.stderr +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_contains_vc_inside_generic.stderr @@ -5,14 +5,14 @@ error[E0277]: the trait bound `Vc: ResolvedValue` is not satisfied | ^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `ResolvedValue` is not implemented for `Vc`, which is required by `Option; 4]>>: ResolvedValue` | = help: the following other types implement trait `ResolvedValue`: - &str + &T + &mut T () (A, Z, Y, X, W, V, U, T) (B, A, Z, Y, X, W, V, U, T) (C, B, A, Z, Y, X, W, V, U, T) (D, C, B, A, Z, Y, X, W, V, U, T) (E, D, C, B, A, Z, Y, X, W, V, U, T) - (T,) and $N others = note: required for `[Vc; 4]` to implement `ResolvedValue` = note: 2 redundant requirements hidden diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_enum.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_enum.rs new file mode 100644 index 0000000000000..931043a001111 --- /dev/null +++ b/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() {} diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_enum.stderr b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_enum.stderr new file mode 100644 index 0000000000000..31871c211e49f --- /dev/null +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_enum.stderr @@ -0,0 +1,45 @@ +error[E0277]: the trait bound `UnresolvedValue: ResolvedValue` is not satisfied + --> tests/derive_resolved_value/fail_simple_enum.rs:10:13 + | +10 | Unnamed(UnresolvedValue), + | ^^^^^^^^^^^^^^^ the trait `ResolvedValue` is not implemented for `UnresolvedValue` + | + = help: the following other types implement trait `ResolvedValue`: + &T + &mut T + () + (A, Z, Y, X, W, V, U, T) + (B, A, Z, Y, X, W, V, U, T) + (C, B, A, Z, Y, X, W, V, U, T) + (D, C, B, A, Z, Y, X, W, V, U, T) + (E, D, C, B, A, Z, Y, X, W, V, U, T) + and $N others +note: required by a bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` + --> tests/derive_resolved_value/fail_simple_enum.rs:7:10 + | +7 | #[derive(ResolvedValue)] + | ^^^^^^^^^^^^^ required by this bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` + = note: this error originates in the derive macro `ResolvedValue` (in Nightly builds, run with -Z macro-backtrace for more info) + +error[E0277]: the trait bound `UnresolvedValue: ResolvedValue` is not satisfied + --> tests/derive_resolved_value/fail_simple_enum.rs:11:16 + | +11 | Named { a: UnresolvedValue }, + | ^^^^^^^^^^^^^^^ the trait `ResolvedValue` is not implemented for `UnresolvedValue` + | + = help: the following other types implement trait `ResolvedValue`: + &T + &mut T + () + (A, Z, Y, X, W, V, U, T) + (B, A, Z, Y, X, W, V, U, T) + (C, B, A, Z, Y, X, W, V, U, T) + (D, C, B, A, Z, Y, X, W, V, U, T) + (E, D, C, B, A, Z, Y, X, W, V, U, T) + and $N others +note: required by a bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` + --> tests/derive_resolved_value/fail_simple_enum.rs:7:10 + | +7 | #[derive(ResolvedValue)] + | ^^^^^^^^^^^^^ required by this bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` + = note: this error originates in the derive macro `ResolvedValue` (in Nightly builds, run with -Z macro-backtrace for more info) diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_named_struct.stderr b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_named_struct.stderr index 49cb721a27d06..57e0b2cae6ce2 100644 --- a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_named_struct.stderr +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_named_struct.stderr @@ -5,14 +5,14 @@ error[E0277]: the trait bound `UnresolvedValue: ResolvedValue` is not satisfied | ^^^^^^^^^^^^^^^ the trait `ResolvedValue` is not implemented for `UnresolvedValue` | = help: the following other types implement trait `ResolvedValue`: - &str + &T + &mut T () (A, Z, Y, X, W, V, U, T) (B, A, Z, Y, X, W, V, U, T) (C, B, A, Z, Y, X, W, V, U, T) (D, C, B, A, Z, Y, X, W, V, U, T) (E, D, C, B, A, Z, Y, X, W, V, U, T) - (T,) and $N others note: required by a bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` --> tests/derive_resolved_value/fail_simple_named_struct.rs:7:10 diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_unnamed_struct.stderr b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_unnamed_struct.stderr index f779b92423904..6052e7151c56e 100644 --- a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_unnamed_struct.stderr +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_simple_unnamed_struct.stderr @@ -5,14 +5,14 @@ error[E0277]: the trait bound `UnresolvedValue: ResolvedValue` is not satisfied | ^^^^^^^^^^^^^^^ the trait `ResolvedValue` is not implemented for `UnresolvedValue` | = help: the following other types implement trait `ResolvedValue`: - &str + &T + &mut T () (A, Z, Y, X, W, V, U, T) (B, A, Z, Y, X, W, V, U, T) (C, B, A, Z, Y, X, W, V, U, T) (D, C, B, A, Z, Y, X, W, V, U, T) (E, D, C, B, A, Z, Y, X, W, V, U, T) - (T,) and $N others note: required by a bound in `DeriveResolvedValueAssertion::assert_impl_resolved_value` --> tests/derive_resolved_value/fail_simple_unnamed_struct.rs:7:10 diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_underconstrained_generic.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_underconstrained_generic.rs new file mode 100644 index 0000000000000..1ccb4149ff1e8 --- /dev/null +++ b/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 { + value: T, +} + +fn main() {} diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_underconstrained_generic.stderr b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_underconstrained_generic.stderr new file mode 100644 index 0000000000000..985703ae8f3fc --- /dev/null +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/fail_underconstrained_generic.stderr @@ -0,0 +1,16 @@ +error[E0277]: the trait bound `T: ResolvedValue` is not satisfied + --> tests/derive_resolved_value/fail_underconstrained_generic.rs:7:12 + | +7 | value: T, + | ^ the trait `ResolvedValue` is not implemented for `T` + | +note: required by a bound in `DeriveResolvedValueAssertion::::assert_impl_resolved_value` + --> tests/derive_resolved_value/fail_underconstrained_generic.rs:5:10 + | +5 | #[derive(ResolvedValue)] + | ^^^^^^^^^^^^^ required by this bound in `DeriveResolvedValueAssertion::::assert_impl_resolved_value` + = note: this error originates in the derive macro `ResolvedValue` (in Nightly builds, run with -Z macro-backtrace for more info) +help: consider restricting type parameter `T` + | +6 | struct ContainsUnderconstrainedGeneric { + | ++++++++++++++++++++++++++++ diff --git a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_lifetimes.rs b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_lifetimes.rs index ebe6e678f1392..58bad80f3cc2b 100644 --- a/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_lifetimes.rs +++ b/crates/turbo-tasks-macros-tests/tests/derive_resolved_value/pass_lifetimes.rs @@ -2,10 +2,12 @@ use turbo_tasks::ResolvedValue; #[derive(ResolvedValue)] struct ContainsBorrowedData<'a> { - borrowed: &'a str, + borrowed: &'a Option<&'a [&'a str]>, } fn main() { - let a = ContainsBorrowedData { borrowed: "value" }; + let a = ContainsBorrowedData { + borrowed: &Some(["value"].as_slice()), + }; let _ = a.borrowed; }