diff --git a/crates/cgp-core/src/prelude.rs b/crates/cgp-core/src/prelude.rs index 086825f0..da9ec3fc 100644 --- a/crates/cgp-core/src/prelude.rs +++ b/crates/cgp-core/src/prelude.rs @@ -19,7 +19,7 @@ pub use cgp_field::types::{ pub use cgp_macro::{ cgp_auto_getter, cgp_component, cgp_context, cgp_getter, cgp_new_provider, cgp_preset, cgp_provider, cgp_type, check_components, delegate_and_check_components, delegate_components, - product, re_export_imports, replace_with, BuildField, CgpVariant, ExtractField, FromVariant, - HasField, HasFields, Product, Sum, Symbol, Symbol as symbol, + product, re_export_imports, replace_with, BuildField, CgpData, CgpRecord, CgpVariant, + ExtractField, FromVariant, HasField, HasFields, Product, Sum, Symbol, Symbol as symbol, }; pub use cgp_type::{HasType, ProvideType, UseType}; diff --git a/crates/cgp-macro-lib/src/entrypoints/cgp_data.rs b/crates/cgp-macro-lib/src/entrypoints/cgp_data.rs new file mode 100644 index 00000000..7d56207b --- /dev/null +++ b/crates/cgp-macro-lib/src/entrypoints/cgp_data.rs @@ -0,0 +1,17 @@ +use proc_macro2::TokenStream; +use syn::{parse2, Error, Item}; + +use crate::{derive_cgp_record_from_struct, derive_cgp_variant_from_enum}; + +pub fn derive_cgp_data(body: TokenStream) -> syn::Result { + let item: Item = parse2(body)?; + + match item { + Item::Struct(item_struct) => derive_cgp_record_from_struct(&item_struct), + Item::Enum(item_enum) => derive_cgp_variant_from_enum(&item_enum), + _ => Err(Error::new_spanned( + item, + "expect body to be either a struct or enum", + )), + } +} diff --git a/crates/cgp-macro-lib/src/entrypoints/cgp_record.rs b/crates/cgp-macro-lib/src/entrypoints/cgp_record.rs new file mode 100644 index 00000000..7024530f --- /dev/null +++ b/crates/cgp-macro-lib/src/entrypoints/cgp_record.rs @@ -0,0 +1,24 @@ +use proc_macro2::TokenStream; +use quote::quote; +use syn::{parse2, ItemStruct}; + +use crate::derive_build_field_from_struct; +use crate::derive_has_fields::derive_has_fields_impls_from_struct; +use crate::field::derive_has_field_impls_from_struct; + +pub fn derive_cgp_record(body: TokenStream) -> syn::Result { + let item_struct = parse2(body)?; + derive_cgp_record_from_struct(&item_struct) +} + +pub fn derive_cgp_record_from_struct(item_struct: &ItemStruct) -> syn::Result { + let has_field_impls = derive_has_field_impls_from_struct(item_struct); + let has_fields_impls = derive_has_fields_impls_from_struct(item_struct)?; + let build_field_impls = derive_build_field_from_struct(item_struct)?; + + Ok(quote! { + #( #has_field_impls )* + #( #has_fields_impls )* + #build_field_impls + }) +} diff --git a/crates/cgp-macro-lib/src/entrypoints/cgp_variant.rs b/crates/cgp-macro-lib/src/entrypoints/cgp_variant.rs index 12776e97..dac757bf 100644 --- a/crates/cgp-macro-lib/src/entrypoints/cgp_variant.rs +++ b/crates/cgp-macro-lib/src/entrypoints/cgp_variant.rs @@ -1,15 +1,22 @@ use proc_macro2::TokenStream; use quote::quote; +use syn::{parse2, ItemEnum}; -use crate::entrypoints::{derive_extract_field, derive_from_variant, derive_has_fields}; +use crate::derive_has_fields::derive_has_fields_impls_from_enum; +use crate::{derive_extract_field_from_enum, derive_from_variant_from_enum}; -pub fn cgp_variant(body: TokenStream) -> syn::Result { - let has_fields = derive_has_fields(body.clone())?; - let extract_field = derive_extract_field(body.clone())?; - let from_variant = derive_from_variant(body)?; +pub fn derive_cgp_variant(body: TokenStream) -> syn::Result { + let item_enum = parse2(body)?; + derive_cgp_variant_from_enum(&item_enum) +} + +pub fn derive_cgp_variant_from_enum(item_enum: &ItemEnum) -> syn::Result { + let has_fields = derive_has_fields_impls_from_enum(item_enum)?; + let extract_field = derive_extract_field_from_enum(item_enum)?; + let from_variant = derive_from_variant_from_enum(item_enum)?; Ok(quote! { - #has_fields + #( #has_fields )* #extract_field #from_variant }) diff --git a/crates/cgp-macro-lib/src/entrypoints/derive_build_field.rs b/crates/cgp-macro-lib/src/entrypoints/derive_build_field.rs index a5f28822..b15f46c2 100644 --- a/crates/cgp-macro-lib/src/entrypoints/derive_build_field.rs +++ b/crates/cgp-macro-lib/src/entrypoints/derive_build_field.rs @@ -10,23 +10,26 @@ use crate::derive_builder::{ pub fn derive_build_field(body: TokenStream) -> syn::Result { let context_struct: ItemStruct = parse2(body)?; + derive_build_field_from_struct(&context_struct) +} +pub fn derive_build_field_from_struct(context_struct: &ItemStruct) -> syn::Result { let context_ident = &context_struct.ident; let builder_ident = Ident::new(&format!("Partial{context_ident}"), context_ident.span()); - let builder_struct = derive_builder_struct(&context_struct, &builder_ident)?; + let builder_struct = derive_builder_struct(context_struct, &builder_ident)?; - let has_builder_impl = derive_has_builder_impl(&context_struct, &builder_ident)?; + let has_builder_impl = derive_has_builder_impl(context_struct, &builder_ident)?; - let into_builder_impl = derive_into_builder_impl(&context_struct, &builder_ident)?; + let into_builder_impl = derive_into_builder_impl(context_struct, &builder_ident)?; - let partial_data_impl = derive_partial_data_impl(&context_struct, &builder_ident)?; + let partial_data_impl = derive_partial_data_impl(context_struct, &builder_ident)?; - let update_field_impls = derive_update_field_impls(&context_struct, &builder_ident)?; + let update_field_impls = derive_update_field_impls(context_struct, &builder_ident)?; - let has_field_impls = derive_has_field_impls(&context_struct, &builder_ident)?; + let has_field_impls = derive_has_field_impls(context_struct, &builder_ident)?; - let finalize_build_impl = derive_finalize_build_impl(&context_struct, &builder_ident)?; + let finalize_build_impl = derive_finalize_build_impl(context_struct, &builder_ident)?; let out = quote! { #builder_struct diff --git a/crates/cgp-macro-lib/src/entrypoints/derive_extract_field.rs b/crates/cgp-macro-lib/src/entrypoints/derive_extract_field.rs index 568d77bb..c8fa30e2 100644 --- a/crates/cgp-macro-lib/src/entrypoints/derive_extract_field.rs +++ b/crates/cgp-macro-lib/src/entrypoints/derive_extract_field.rs @@ -10,37 +10,36 @@ use crate::derive_extractor::{ pub fn derive_extract_field(body: TokenStream) -> syn::Result { let context_enum: ItemEnum = parse2(body)?; + derive_extract_field_from_enum(&context_enum) +} +pub fn derive_extract_field_from_enum(context_enum: &ItemEnum) -> syn::Result { let context_ident = &context_enum.ident; let extractor_ident = Ident::new(&format!("Partial{context_ident}"), context_ident.span()); - let extractor_enum = derive_extractor_enum(&context_enum, &extractor_ident)?; + let extractor_enum = derive_extractor_enum(context_enum, &extractor_ident)?; let extractor_ref_ident = Ident::new(&format!("PartialRef{context_ident}"), context_ident.span()); - let extractor_ref_enum = derive_extractor_enum_ref(&context_enum, &extractor_ref_ident)?; + let extractor_ref_enum = derive_extractor_enum_ref(context_enum, &extractor_ref_ident)?; - let has_extractor_impl = derive_has_extractor_impl(&context_enum, &extractor_ident)?; + let has_extractor_impl = derive_has_extractor_impl(context_enum, &extractor_ident)?; - let has_extractor_ref_impl = - derive_has_extractor_ref_impl(&context_enum, &extractor_ref_ident)?; + let has_extractor_ref_impl = derive_has_extractor_ref_impl(context_enum, &extractor_ref_ident)?; - let has_extractor_mut_impl = - derive_has_extractor_mut_impl(&context_enum, &extractor_ref_ident)?; + let has_extractor_mut_impl = derive_has_extractor_mut_impl(context_enum, &extractor_ref_ident)?; let finalize_extract_impl = - derive_finalize_extract_impl(&context_enum, &extractor_ident, false)?; + derive_finalize_extract_impl(context_enum, &extractor_ident, false)?; let finalize_extract_ref_impl = - derive_finalize_extract_impl(&context_enum, &extractor_ref_ident, true)?; + derive_finalize_extract_impl(context_enum, &extractor_ref_ident, true)?; - let partial_data_impl = derive_partial_data_impl(&context_enum, &extractor_ident, false)?; - let partial_ref_data_impl = - derive_partial_data_impl(&context_enum, &extractor_ref_ident, true)?; + let partial_data_impl = derive_partial_data_impl(context_enum, &extractor_ident, false)?; + let partial_ref_data_impl = derive_partial_data_impl(context_enum, &extractor_ref_ident, true)?; - let extractor_impls = derive_extract_field_impls(&context_enum, &extractor_ident, false)?; - let extractor_ref_impls = - derive_extract_field_impls(&context_enum, &extractor_ref_ident, true)?; + let extractor_impls = derive_extract_field_impls(context_enum, &extractor_ident, false)?; + let extractor_ref_impls = derive_extract_field_impls(context_enum, &extractor_ref_ident, true)?; let out = quote! { #extractor_enum diff --git a/crates/cgp-macro-lib/src/entrypoints/derive_from_variant.rs b/crates/cgp-macro-lib/src/entrypoints/derive_from_variant.rs index 3d230723..43c8c123 100644 --- a/crates/cgp-macro-lib/src/entrypoints/derive_from_variant.rs +++ b/crates/cgp-macro-lib/src/entrypoints/derive_from_variant.rs @@ -7,16 +7,21 @@ use crate::symbol::symbol_from_string; pub fn derive_from_variant(body: TokenStream) -> syn::Result { let item_enum: ItemEnum = parse2(body)?; + + derive_from_variant_from_enum(&item_enum) +} + +pub fn derive_from_variant_from_enum(item_enum: &ItemEnum) -> syn::Result { let enum_ident = &item_enum.ident; let (impl_generics, ty_generics, where_clause) = item_enum.generics.split_for_impl(); let mut item_impls: Vec = Vec::new(); - for variant in item_enum.variants { + for variant in item_enum.variants.iter() { let variant_ident = &variant.ident; let variant_tag = symbol_from_string(&variant_ident.to_string()); - let variant_type = get_variant_type(&variant)?; + let variant_type = get_variant_type(variant)?; let item_impl: ItemImpl = parse2(quote! { impl #impl_generics FromVariant<#variant_tag> for #enum_ident #ty_generics diff --git a/crates/cgp-macro-lib/src/entrypoints/derive_has_fields.rs b/crates/cgp-macro-lib/src/entrypoints/derive_has_fields.rs index 8e992c58..2238e9d0 100644 --- a/crates/cgp-macro-lib/src/entrypoints/derive_has_fields.rs +++ b/crates/cgp-macro-lib/src/entrypoints/derive_has_fields.rs @@ -1,5 +1,5 @@ use proc_macro2::TokenStream; -use quote::TokenStreamExt; +use quote::quote; use syn::{parse2, Error, Item}; use crate::derive_has_fields::{ @@ -20,9 +20,7 @@ pub fn derive_has_fields(body: TokenStream) -> syn::Result { } }; - let mut out = TokenStream::new(); - - out.append_all(impls); - - Ok(out) + Ok(quote! { + #( #impls )* + }) } diff --git a/crates/cgp-macro-lib/src/entrypoints/mod.rs b/crates/cgp-macro-lib/src/entrypoints/mod.rs index 23c1f2c4..ba5bdc44 100644 --- a/crates/cgp-macro-lib/src/entrypoints/mod.rs +++ b/crates/cgp-macro-lib/src/entrypoints/mod.rs @@ -2,10 +2,12 @@ mod blanket_trait; mod cgp_auto_getter; mod cgp_component; mod cgp_context; +mod cgp_data; mod cgp_getter; mod cgp_new_provider; mod cgp_preset; mod cgp_provider; +mod cgp_record; mod cgp_type; mod cgp_variant; mod check_components; @@ -22,10 +24,12 @@ pub use blanket_trait::*; pub use cgp_auto_getter::*; pub use cgp_component::*; pub use cgp_context::*; +pub use cgp_data::*; pub use cgp_getter::*; pub use cgp_new_provider::*; pub use cgp_preset::*; pub use cgp_provider::*; +pub use cgp_record::*; pub use cgp_type::*; pub use cgp_variant::*; pub use check_components::*; diff --git a/crates/cgp-macro-lib/src/field.rs b/crates/cgp-macro-lib/src/field.rs index 16a5eea7..d08c95c5 100644 --- a/crates/cgp-macro-lib/src/field.rs +++ b/crates/cgp-macro-lib/src/field.rs @@ -2,13 +2,13 @@ use alloc::string::ToString; use alloc::vec::Vec; use proc_macro2::TokenStream; -use quote::{quote, ToTokens}; +use quote::quote; use syn::spanned::Spanned; use syn::{parse_quote, Fields, ItemImpl, ItemStruct, LitInt}; use crate::symbol::symbol_from_string; -pub fn derive_has_field_impls(item_struct: &ItemStruct) -> Vec { +pub fn derive_has_field_impls_from_struct(item_struct: &ItemStruct) -> Vec { let struct_ident = &item_struct.ident; let (impl_generics, ty_generics, where_clause) = item_struct.generics.split_for_impl(); @@ -109,16 +109,12 @@ pub fn derive_has_field_impls(item_struct: &ItemStruct) -> Vec { item_impls } -pub fn derive_fields(input: TokenStream) -> TokenStream { +pub fn derive_has_field(input: TokenStream) -> TokenStream { let item_struct: ItemStruct = syn::parse2(input).unwrap(); - let item_impls = derive_has_field_impls(&item_struct); + let item_impls = derive_has_field_impls_from_struct(&item_struct); - let mut output = TokenStream::new(); - - for item_impl in item_impls { - output.extend(item_impl.to_token_stream()); + quote! { + #( #item_impls )* } - - output } diff --git a/crates/cgp-macro-lib/src/lib.rs b/crates/cgp-macro-lib/src/lib.rs index 60a69c9f..39f06cd3 100644 --- a/crates/cgp-macro-lib/src/lib.rs +++ b/crates/cgp-macro-lib/src/lib.rs @@ -29,7 +29,7 @@ pub(crate) mod product; pub(crate) mod symbol; pub(crate) mod type_component; -pub use field::derive_fields; +pub use field::derive_has_field; pub use product::{make_product_expr, make_product_type, make_sum_type}; pub use symbol::make_symbol; diff --git a/crates/cgp-macro-lib/src/tests/field.rs b/crates/cgp-macro-lib/src/tests/field.rs index 35986504..a5038893 100644 --- a/crates/cgp-macro-lib/src/tests/field.rs +++ b/crates/cgp-macro-lib/src/tests/field.rs @@ -1,11 +1,11 @@ use quote::quote; -use crate::field::derive_fields; +use crate::field::derive_has_field; use crate::tests::helper::equal::equal_token_stream; #[test] fn test_basic_derive_fields() { - let derived = derive_fields(quote! { + let derived = derive_has_field(quote! { pub struct Foo { pub bar: Bar, pub baz: Baz, @@ -59,7 +59,7 @@ fn test_basic_derive_fields() { #[test] fn test_generic_derive_fields() { - let derived = derive_fields(quote! { + let derived = derive_has_field(quote! { pub struct Foo where FooParamA: Eq, diff --git a/crates/cgp-macro/src/lib.rs b/crates/cgp-macro/src/lib.rs index 45700299..d75f3a00 100644 --- a/crates/cgp-macro/src/lib.rs +++ b/crates/cgp-macro/src/lib.rs @@ -940,7 +940,7 @@ pub fn product(body: TokenStream) -> TokenStream { #[proc_macro_derive(HasField)] pub fn derive_fields(item: TokenStream) -> TokenStream { - cgp_macro_lib::derive_fields(item.into()).into() + cgp_macro_lib::derive_has_field(item.into()).into() } #[proc_macro_derive(HasFields)] @@ -973,7 +973,21 @@ pub fn derive_from_variant(item: TokenStream) -> TokenStream { #[proc_macro_derive(CgpVariant)] pub fn derive_cgp_variant(item: TokenStream) -> TokenStream { - cgp_macro_lib::cgp_variant(item.into()) + cgp_macro_lib::derive_cgp_variant(item.into()) + .unwrap_or_else(syn::Error::into_compile_error) + .into() +} + +#[proc_macro_derive(CgpRecord)] +pub fn derive_cgp_record(item: TokenStream) -> TokenStream { + cgp_macro_lib::derive_cgp_record(item.into()) + .unwrap_or_else(syn::Error::into_compile_error) + .into() +} + +#[proc_macro_derive(CgpData)] +pub fn derive_cgp_data(item: TokenStream) -> TokenStream { + cgp_macro_lib::derive_cgp_data(item.into()) .unwrap_or_else(syn::Error::into_compile_error) .into() } diff --git a/crates/cgp-tests/tests/extensible_data_tests/records/basic.rs b/crates/cgp-tests/tests/extensible_data_tests/records/basic.rs index a0b47c24..8b660bf5 100644 --- a/crates/cgp-tests/tests/extensible_data_tests/records/basic.rs +++ b/crates/cgp-tests/tests/extensible_data_tests/records/basic.rs @@ -7,20 +7,20 @@ use cgp::extra::dispatch::{BuildAndMerge, BuildAndSetField, BuildWithHandlers}; use cgp::extra::handler::{Computer, Producer, ProducerComponent}; use cgp::prelude::*; -#[derive(Debug, Eq, PartialEq, HasFields, BuildField)] +#[derive(Debug, Eq, PartialEq, CgpData)] pub struct FooBarBaz { pub foo: u64, pub bar: String, pub baz: bool, } -#[derive(Debug, Eq, PartialEq, HasFields, BuildField)] +#[derive(Debug, Eq, PartialEq, CgpData)] pub struct FooBar { pub foo: u64, pub bar: String, } -#[derive(Debug, Eq, PartialEq, HasFields, BuildField)] +#[derive(Debug, Eq, PartialEq, CgpData)] pub struct Baz { pub baz: bool, } diff --git a/crates/cgp-tests/tests/extensible_data_tests/records/generics.rs b/crates/cgp-tests/tests/extensible_data_tests/records/generics.rs index c4ebc3f0..4bc1be53 100644 --- a/crates/cgp-tests/tests/extensible_data_tests/records/generics.rs +++ b/crates/cgp-tests/tests/extensible_data_tests/records/generics.rs @@ -1,6 +1,6 @@ use cgp::prelude::*; -#[derive(BuildField)] +#[derive(CgpData)] pub struct Context where Foo: Clone, diff --git a/crates/cgp-tests/tests/extensible_data_tests/records/index.rs b/crates/cgp-tests/tests/extensible_data_tests/records/index.rs index 44b58203..681ea680 100644 --- a/crates/cgp-tests/tests/extensible_data_tests/records/index.rs +++ b/crates/cgp-tests/tests/extensible_data_tests/records/index.rs @@ -1,4 +1,4 @@ use cgp::prelude::*; -#[derive(BuildField)] +#[derive(CgpData)] pub struct Context(pub u64, pub String, pub bool); diff --git a/crates/cgp-tests/tests/extensible_data_tests/records/optional.rs b/crates/cgp-tests/tests/extensible_data_tests/records/optional.rs index a1d9539a..9b45dc37 100644 --- a/crates/cgp-tests/tests/extensible_data_tests/records/optional.rs +++ b/crates/cgp-tests/tests/extensible_data_tests/records/optional.rs @@ -3,7 +3,7 @@ use cgp::extra::field::impls::{ }; use cgp::prelude::*; -#[derive(HasFields, BuildField)] +#[derive(CgpData)] pub struct Context { pub foo: String, pub bar: u64, diff --git a/crates/cgp-tests/tests/extensible_data_tests/records/person.rs b/crates/cgp-tests/tests/extensible_data_tests/records/person.rs index 79f535bb..aef61b21 100644 --- a/crates/cgp-tests/tests/extensible_data_tests/records/person.rs +++ b/crates/cgp-tests/tests/extensible_data_tests/records/person.rs @@ -2,20 +2,20 @@ use cgp::core::field::impls::CanBuildFrom; use cgp::extra::dispatch::{BuildAndMerge, BuildAndSetField, BuildWithHandlers}; use cgp::prelude::*; -#[derive(HasFields, BuildField)] +#[derive(CgpData)] pub struct Person { pub first_name: String, pub last_name: String, } -#[derive(HasFields, BuildField)] +#[derive(CgpData)] pub struct Employee { pub employee_id: u64, pub first_name: String, pub last_name: String, } -#[derive(HasFields, BuildField)] +#[derive(CgpData)] pub struct EmployeeId { pub employee_id: u64, } diff --git a/crates/cgp-tests/tests/extensible_data_tests/records/point.rs b/crates/cgp-tests/tests/extensible_data_tests/records/point.rs index e6b39dff..d1b65ffa 100644 --- a/crates/cgp-tests/tests/extensible_data_tests/records/point.rs +++ b/crates/cgp-tests/tests/extensible_data_tests/records/point.rs @@ -1,20 +1,20 @@ use cgp::extra::field::impls::CanBuildWithDefault; use cgp::prelude::*; -#[derive(Debug, Clone, Eq, PartialEq, HasFields, BuildField)] +#[derive(Debug, Clone, Eq, PartialEq, CgpData)] struct Point2d { x: u64, y: u64, } -#[derive(Debug, Clone, Eq, PartialEq, HasFields, BuildField)] +#[derive(Debug, Clone, Eq, PartialEq, CgpData)] struct Point3d { x: u64, y: u64, z: u64, } -#[derive(Debug, Clone, Eq, PartialEq, HasFields, BuildField)] +#[derive(Debug, Clone, Eq, PartialEq, CgpData)] struct Point4d { x: u64, y: u64, diff --git a/crates/cgp-tests/tests/extensible_data_tests/variants/basic.rs b/crates/cgp-tests/tests/extensible_data_tests/variants/basic.rs index 54a15047..a2c8c204 100644 --- a/crates/cgp-tests/tests/extensible_data_tests/variants/basic.rs +++ b/crates/cgp-tests/tests/extensible_data_tests/variants/basic.rs @@ -12,25 +12,25 @@ use cgp::extra::handler::{Computer, ComputerComponent, ComputerRefComponent, Pro use cgp::prelude::*; use futures::executor::block_on; -#[derive(Debug, Eq, PartialEq, HasFields, ExtractField, FromVariant)] +#[derive(Debug, Eq, PartialEq, CgpData)] pub enum FooBarBaz { Foo(u64), Bar(String), Baz(bool), } -#[derive(Debug, Eq, PartialEq, HasFields, ExtractField, FromVariant)] +#[derive(Debug, Eq, PartialEq, CgpData)] pub enum FooBar { Foo(u64), Bar(String), } -#[derive(Debug, Eq, PartialEq, HasFields, ExtractField, FromVariant)] +#[derive(Debug, Eq, PartialEq, CgpData)] pub enum Baz { Baz(bool), } -#[derive(Debug, Eq, PartialEq, HasFields, ExtractField, FromVariant)] +#[derive(Debug, Eq, PartialEq, CgpData)] pub enum BazBarFoo { Baz(bool), Bar(String), diff --git a/crates/cgp-tests/tests/extensible_data_tests/variants/generic.rs b/crates/cgp-tests/tests/extensible_data_tests/variants/generic.rs index 24b6f815..9213f8c9 100644 --- a/crates/cgp-tests/tests/extensible_data_tests/variants/generic.rs +++ b/crates/cgp-tests/tests/extensible_data_tests/variants/generic.rs @@ -1,14 +1,14 @@ use cgp::core::field::impls::{CanDowncast, CanUpcast}; use cgp::prelude::*; -#[derive(Debug, Eq, PartialEq, HasFields, ExtractField, FromVariant)] +#[derive(Debug, Eq, PartialEq, CgpData)] pub enum FooBarBazGeneric { Foo(Foo), Bar(Bar), Baz(Baz), } -#[derive(Debug, Eq, PartialEq, HasFields, ExtractField, FromVariant)] +#[derive(Debug, Eq, PartialEq, CgpData)] pub enum FooBarGeneric { Foo(Foo), Bar(Bar), diff --git a/crates/cgp-tests/tests/extensible_data_tests/variants/shape.rs b/crates/cgp-tests/tests/extensible_data_tests/variants/shape.rs index fcc9f233..164cb647 100644 --- a/crates/cgp-tests/tests/extensible_data_tests/variants/shape.rs +++ b/crates/cgp-tests/tests/extensible_data_tests/variants/shape.rs @@ -9,18 +9,18 @@ use cgp::extra::dispatch::{ use cgp::extra::handler::{NoCode, UseInputDelegate}; use cgp::prelude::*; -#[derive(Debug, PartialEq, HasFields, FromVariant, ExtractField)] +#[derive(Debug, PartialEq, CgpData)] pub enum Shape { Circle(Circle), Rectangle(Rectangle), } -#[derive(Debug, PartialEq, HasFields, FromVariant, ExtractField)] +#[derive(Debug, PartialEq, CgpData)] pub enum TriangleOnly { Triangle(Triangle), } -#[derive(Debug, PartialEq, HasFields, FromVariant, ExtractField)] +#[derive(Debug, PartialEq, CgpData)] pub enum ShapePlus { Triangle(Triangle), Rectangle(Rectangle),