diff --git a/crates/macros/cgp-macro-lib/src/delegate_components/impl_delegate.rs b/crates/macros/cgp-macro-lib/src/delegate_components/impl_delegate.rs deleted file mode 100644 index 2708cacc..00000000 --- a/crates/macros/cgp-macro-lib/src/delegate_components/impl_delegate.rs +++ /dev/null @@ -1,151 +0,0 @@ -use alloc::boxed::Box; -use alloc::vec; -use alloc::vec::Vec; - -use cgp_macro_core::functions::merge_generics; -use cgp_macro_core::types::empty_struct::EmptyStruct; -use cgp_macro_core::types::generics::ImplGenerics; -use proc_macro2::TokenStream; -use quote::{ToTokens, quote}; -use syn::punctuated::Punctuated; -use syn::token::Comma; -use syn::{ImplItem, ImplItemType, ItemImpl, Path, Type, parse2}; - -use crate::parse::{DelegateEntry, DelegateKey, DelegateMode, DelegateValue}; - -pub fn impl_delegate_components( - target_type: &Type, - target_generics: &ImplGenerics, - delegate_entries: &Punctuated, Comma>, -) -> syn::Result -where - T: ToTokens, -{ - let mut out = TokenStream::new(); - - for entry in delegate_entries.iter() { - let source = &entry.value; - for component in entry.keys.iter() { - let impls = impl_delegate_component( - target_type, - target_generics, - component, - source, - &entry.mode, - )?; - - out.extend(impls); - } - - if let DelegateValue::New(value) = source { - let struct_ident = &value.struct_ident; - - let item_struct = EmptyStruct { - ident: struct_ident.clone(), - generics: value.struct_generics.clone(), - }; - - let (impl_generics, type_generics, _) = value.struct_generics.split_for_impl(); - - let target_type: Type = parse2(quote! { #struct_ident #type_generics })?; - - let impl_generics = parse2(quote! { #impl_generics })?; - - let inner_impls = - impl_delegate_components(&target_type, &impl_generics, &value.entries)?; - - out.extend(item_struct.to_token_stream()); - out.extend(inner_impls); - } - } - - Ok(out) -} - -pub fn impl_delegate_component( - target_type: &Type, - target_generics: &ImplGenerics, - component: &DelegateKey, - value: &DelegateValue, - mode: &DelegateMode, -) -> syn::Result -where - T: ToTokens, -{ - let component_type = &component.ty; - - let delegate_target_type = match mode { - DelegateMode::Provider(_) => value.as_type(), - DelegateMode::Direct(_) => { - let value_type = value.as_type(); - parse2(quote! { - < #value_type as DelegateComponent< #component_type > >::Delegate - })? - } - }; - - let delegate_trait_path: Path = parse2(quote!(DelegateComponent < #component_type >))?; - - let delegate_type: ImplItemType = parse2(quote!(type Delegate = #delegate_target_type;))?; - - let mut delegate_generics = - merge_generics(&target_generics.generics, &component.generics.generics); - - if mode.is_direct() { - let value_type = value.as_type(); - let where_clause = delegate_generics.make_where_clause(); - - where_clause.predicates.push(parse2( - quote!( #value_type : DelegateComponent< #component_type > ), - )?); - } - - let is_provider_generics = { - let mut generics = delegate_generics.clone(); - - generics.params.push(parse2(quote!(__Context__))?); - generics.params.push(parse2(quote!(__Params__))?); - - let where_clause = generics.make_where_clause(); - - where_clause.predicates.push(parse2( - quote!( #delegate_target_type : IsProviderFor< #component_type, __Context__, __Params__ > ), - )?); - - generics - }; - - let delegate_impl = ItemImpl { - attrs: Vec::new(), - defaultness: None, - unsafety: None, - impl_token: Default::default(), - generics: delegate_generics, - trait_: Some((None, delegate_trait_path, Default::default())), - self_ty: Box::new(target_type.clone()), - brace_token: Default::default(), - items: vec![ImplItem::Type(delegate_type)], - }; - - let is_provider_trait_path: Path = - parse2(quote!( IsProviderFor< #component_type, __Context__, __Params__ > ))?; - - let is_provider_impl = ItemImpl { - attrs: Vec::new(), - defaultness: None, - unsafety: None, - impl_token: Default::default(), - generics: is_provider_generics, - trait_: Some((None, is_provider_trait_path, Default::default())), - self_ty: Box::new(target_type.clone()), - brace_token: Default::default(), - items: Default::default(), - }; - - let out = quote! { - #delegate_impl - #is_provider_impl - }; - - Ok(out) -} diff --git a/crates/macros/cgp-macro-lib/src/delegate_components/mod.rs b/crates/macros/cgp-macro-lib/src/delegate_components/mod.rs deleted file mode 100644 index c9f86cb6..00000000 --- a/crates/macros/cgp-macro-lib/src/delegate_components/mod.rs +++ /dev/null @@ -1,3 +0,0 @@ -mod impl_delegate; - -pub use impl_delegate::*; diff --git a/crates/macros/cgp-macro-lib/src/entrypoints/mod.rs b/crates/macros/cgp-macro-lib/src/entrypoints/mod.rs index f3036c36..18100ecc 100644 --- a/crates/macros/cgp-macro-lib/src/entrypoints/mod.rs +++ b/crates/macros/cgp-macro-lib/src/entrypoints/mod.rs @@ -5,10 +5,8 @@ mod cgp_data; mod cgp_fn; mod cgp_getter; mod cgp_impl; -mod cgp_inherit; mod cgp_namespace; mod cgp_new_provider; -mod cgp_preset; mod cgp_provider; mod cgp_record; mod cgp_type; @@ -21,8 +19,6 @@ mod derive_extract_field; mod derive_from_variant; mod derive_has_fields; mod path; -mod re_export_imports; -mod replace_with; pub use blanket_trait::*; pub use cgp_auto_getter::*; @@ -31,10 +27,8 @@ pub use cgp_data::*; pub use cgp_fn::*; pub use cgp_getter::*; pub use cgp_impl::*; -pub use cgp_inherit::*; pub use cgp_namespace::*; pub use cgp_new_provider::*; -pub use cgp_preset::*; pub use cgp_provider::*; pub use cgp_record::*; pub use cgp_type::*; @@ -47,5 +41,3 @@ pub use derive_extract_field::*; pub use derive_from_variant::*; pub use derive_has_fields::*; pub use path::*; -pub use re_export_imports::*; -pub use replace_with::*; diff --git a/crates/macros/cgp-macro-lib/src/for_each_replace.rs b/crates/macros/cgp-macro-lib/src/for_each_replace.rs deleted file mode 100644 index 6133e13f..00000000 --- a/crates/macros/cgp-macro-lib/src/for_each_replace.rs +++ /dev/null @@ -1,108 +0,0 @@ -use alloc::vec::Vec; - -use cgp_macro_core::types::ident::IdentWithTypeArgs; -use proc_macro2::{Group, TokenStream, TokenTree}; -use quote::ToTokens; -use syn::__private::parse_brackets; -use syn::parse::discouraged::Speculative; -use syn::parse::{Parse, ParseStream}; -use syn::punctuated::Punctuated; -use syn::token::{Comma, Or}; -use syn::{Ident, braced}; - -use crate::parse::DelegateKey; - -pub struct ReplaceSpecs { - pub target_ident: Ident, - pub replacements: Vec, - pub body: TokenStream, -} - -impl Parse for ReplaceSpecs { - fn parse(input: ParseStream) -> syn::Result { - let raw_replacements: Vec> = { - let content = parse_brackets(input)?.content; - let types = - , Comma>>::parse_terminated(&content)?; - types.into_iter().collect() - }; - - Comma::parse(input)?; - - let exclude: Vec = { - let fork = input.fork(); - - match parse_brackets(&fork) { - Ok(bracket) => { - let types = >::parse_terminated(&bracket.content)?; - - input.advance_to(&fork); - Comma::parse(input)?; - - types.into_iter().collect() - } - _ => Vec::new(), - } - }; - - Or::parse(input)?; - - let target_ident = Ident::parse(input)?; - - Or::parse(input)?; - - let body = { - let content; - braced!(content in input); - TokenStream::parse(&content)? - }; - - let replacements = raw_replacements - .into_iter() - .filter(|replacement| { - let target_ident = &replacement.ty.ident; - - exclude.iter().all(|exclude| exclude != target_ident) - }) - .map(|ast| ast.to_token_stream()) - .collect(); - - Ok(ReplaceSpecs { - target_ident, - replacements, - body, - }) - } -} - -pub fn replace_stream( - target_ident: &Ident, - replacement: &TokenStream, - body: TokenStream, -) -> TokenStream { - body.into_iter() - .map(|tree| replace_tree(target_ident, replacement, tree)) - .collect() -} - -pub fn replace_tree( - target_ident: &Ident, - replacement: &TokenStream, - body: TokenTree, -) -> TokenStream { - match body { - TokenTree::Group(group) => TokenTree::Group(Group::new( - group.delimiter(), - replace_stream(target_ident, replacement, group.stream()), - )) - .into(), - TokenTree::Ident(ident) => { - if &ident == target_ident { - replacement.to_token_stream() - } else { - TokenTree::Ident(ident).into() - } - } - tokens => tokens.into(), - } -} diff --git a/crates/macros/cgp-macro-lib/src/lib.rs b/crates/macros/cgp-macro-lib/src/lib.rs index 372591f8..e709d0fe 100644 --- a/crates/macros/cgp-macro-lib/src/lib.rs +++ b/crates/macros/cgp-macro-lib/src/lib.rs @@ -7,14 +7,10 @@ extern crate alloc; -pub(crate) mod delegate_components; pub(crate) mod derive_builder; pub(crate) mod derive_extractor; pub(crate) mod derive_has_fields; pub(crate) mod field; -pub(crate) mod for_each_replace; -pub(crate) mod parse; -pub(crate) mod preset; pub(crate) mod product; pub(crate) mod symbol; pub(crate) mod type_component; diff --git a/crates/macros/cgp-macro-lib/src/parse/define_preset.rs b/crates/macros/cgp-macro-lib/src/parse/define_preset.rs deleted file mode 100644 index 3de9e30d..00000000 --- a/crates/macros/cgp-macro-lib/src/parse/define_preset.rs +++ /dev/null @@ -1,135 +0,0 @@ -use cgp_macro_core::types::ident::IdentWithTypeArgs; -use proc_macro2::TokenStream; -use quote::ToTokens; -use syn::parse::{Parse, ParseStream}; -use syn::punctuated::Punctuated; -use syn::token::{At, Colon, Comma, Override, Plus, Pound}; -use syn::{Error, Ident, braced, bracketed, parenthesized}; - -use crate::parse::{DelegateEntry, TypeSpec}; - -pub struct DefinePreset { - pub provider_wrapper: Option, - pub preset: TypeSpec, - pub parent_presets: Punctuated, - pub delegate_entries: Punctuated, -} - -pub struct DelegatePresetEntry { - pub is_override: Option, - pub entry: DelegateEntry, -} - -impl Parse for DefinePreset { - fn parse(input: ParseStream) -> syn::Result { - let provider_wrapper: Option = if input.peek(Pound) { - let _: Pound = input.parse()?; - - let body; - bracketed!(body in input); - - let meta: Ident = body.parse()?; - if meta != "wrap_provider" { - return Err(Error::new( - meta.span(), - format!("unsupported attribute: {meta}"), - )); - } - - let body2; - parenthesized!(body2 in body); - - Some(body2.parse()?) - } else { - None - }; - - let PresetHead { - preset, - parent_presets, - } = input.parse()?; - - let delegate_entries = { - let inner; - braced!(inner in input); - Punctuated::parse_terminated(&inner)? - }; - - Ok(Self { - provider_wrapper, - preset, - parent_presets, - delegate_entries, - }) - } -} - -impl Parse for DelegatePresetEntry { - fn parse(input: ParseStream) -> syn::Result { - let is_override = if input.peek(Override) { - let is_override = input.parse()?; - Some(is_override) - } else { - None - }; - - let entry = input.parse()?; - - Ok(Self { is_override, entry }) - } -} - -#[derive(Clone)] -pub struct PresetParent { - pub has_expanded: Option, - pub parent_type: IdentWithTypeArgs, -} - -impl Parse for PresetParent { - fn parse(input: ParseStream) -> syn::Result { - let has_expanded = input.parse()?; - let parent_type = input.parse()?; - - Ok(Self { - has_expanded, - parent_type, - }) - } -} - -impl ToTokens for DelegatePresetEntry { - fn to_tokens(&self, tokens: &mut TokenStream) { - self.is_override.to_tokens(tokens); - self.entry.to_tokens(tokens); - } -} - -impl ToTokens for PresetParent { - fn to_tokens(&self, tokens: &mut TokenStream) { - self.has_expanded.to_tokens(tokens); - self.parent_type.to_tokens(tokens); - } -} - -pub struct PresetHead { - pub preset: TypeSpec, - pub parent_presets: Punctuated, -} - -impl Parse for PresetHead { - fn parse(input: ParseStream) -> syn::Result { - let preset = input.parse()?; - - let parent_presets = if input.peek(Colon) { - let _: Colon = input.parse()?; - Punctuated::parse_separated_nonempty(input)? - } else { - Default::default() - }; - - Ok(Self { - preset, - parent_presets, - }) - } -} diff --git a/crates/macros/cgp-macro-lib/src/parse/delegate_components.rs b/crates/macros/cgp-macro-lib/src/parse/delegate_components.rs deleted file mode 100644 index 736aaf1d..00000000 --- a/crates/macros/cgp-macro-lib/src/parse/delegate_components.rs +++ /dev/null @@ -1,301 +0,0 @@ -use core::iter; - -use cgp_macro_core::functions::merge_generics; -use cgp_macro_core::types::generics::{ImplGenerics, TypeGenerics}; -use cgp_macro_core::types::ident::IdentWithTypeArgs; -use proc_macro2::TokenStream; -use quote::{ToTokens, TokenStreamExt, quote}; -use syn::parse::discouraged::Speculative; -use syn::parse::{Parse, ParseStream}; -use syn::punctuated::Punctuated; -use syn::token::{At, Bracket, Colon, Comma, Gt, Lt, RArrow}; -use syn::{Error, Generics, Ident, Token, Type, braced, bracketed, parse_quote}; - -use crate::parse::ComponentPaths; - -#[derive(Clone)] -pub struct DelegateEntry { - pub keys: Punctuated, Comma>, - pub mode: DelegateMode, - pub value: DelegateValue, -} - -#[derive(Clone)] -pub struct DelegateKey { - pub ty: T, - pub generics: ImplGenerics, -} - -#[derive(Clone)] -pub enum DelegateValue { - Type(Type), - New(DelegateNewValue), -} - -#[derive(Clone)] -pub enum DelegateMode { - Provider(Colon), - Direct(RArrow), -} - -#[derive(Clone)] -pub struct DelegateNewValue { - pub wrapper_ident: Ident, - pub struct_ident: Ident, - pub struct_generics: Generics, - pub entries: Punctuated, Comma>, -} - -impl DelegateMode { - pub fn is_direct(&self) -> bool { - matches!(self, Self::Direct(_)) - } -} -impl DelegateValue { - pub fn as_type(&self) -> Type { - match self { - Self::Type(ty) => ty.clone(), - Self::New(value) => { - let wrapper_ident = &value.wrapper_ident; - let struct_ident = &value.struct_ident; - let (_, struct_generics, _) = value.struct_generics.split_for_impl(); - parse_quote!( #wrapper_ident < #struct_ident #struct_generics > ) - } - } - } -} - -impl Parse for DelegateEntry { - fn parse(input: ParseStream) -> syn::Result { - let components = if input.peek(Bracket) { - let components_body; - bracketed!(components_body in input); - components_body.parse_terminated(DelegateKey::parse, Token![,])? - } else { - let impl_generics: Option = if input.peek(Lt) { - Some(input.parse()?) - } else { - None - }; - - if input.peek(At) { - let _: At = input.parse()?; - - let path: ComponentPaths = input.parse()?; - - let mut keys = Punctuated::new(); - - for path in path.paths { - let generics = if let Some(impl_generics) = &impl_generics { - ImplGenerics { - generics: merge_generics( - &impl_generics.generics, - &path.generics.generics, - ), - } - } else { - path.generics - }; - - let key = DelegateKey { - ty: path.path_type, - generics, - }; - - keys.push(key); - } - - keys - } else { - let mut key: DelegateKey = input.parse()?; - - if let Some(impl_generics) = impl_generics { - key.generics = impl_generics; - } - - Punctuated::from_iter(iter::once(key)) - } - }; - - let mode = input.parse()?; - - let source = input.parse()?; - - Ok(Self { - keys: components, - mode, - value: source, - }) - } -} - -impl Parse for DelegateEntry { - fn parse(input: ParseStream) -> syn::Result { - let components = if input.peek(Bracket) { - let components_body; - bracketed!(components_body in input); - components_body.parse_terminated(DelegateKey::parse, Token![,])? - } else { - let component: DelegateKey = input.parse()?; - Punctuated::from_iter(iter::once(component)) - }; - - let mode = input.parse()?; - - let source = input.parse()?; - - Ok(Self { - keys: components, - mode, - value: source, - }) - } -} - -impl Parse for DelegateKey { - fn parse(input: ParseStream) -> syn::Result { - let component_generics: ImplGenerics = if input.peek(Lt) { - input.parse()? - } else { - Default::default() - }; - - let component_type: Type = input.parse()?; - - Ok(Self { - ty: component_type, - generics: component_generics, - }) - } -} - -impl Parse for DelegateMode { - fn parse(input: ParseStream) -> syn::Result { - if input.peek(RArrow) { - Ok(Self::Direct(input.parse()?)) - } else { - Ok(Self::Provider(input.parse()?)) - } - } -} - -impl Parse for DelegateValue { - fn parse(input: ParseStream) -> syn::Result { - let fork = input.fork(); - - if let Ok(value) = fork.parse::() { - input.advance_to(&fork); - return Ok(Self::New(value)); - } - - let ty: Type = input.parse()?; - Ok(Self::Type(ty)) - } -} - -impl Parse for DelegateNewValue { - fn parse(input: ParseStream) -> syn::Result { - let wrapper_ident = input.parse()?; - - let _: Lt = input.parse()?; - - let new_ident: Ident = input.parse()?; - - if new_ident != "new" { - return Err(Error::new(new_ident.span(), "expect `new` keyword")); - } - - let struct_ident = input.parse()?; - - let struct_generics: TypeGenerics = input.parse()?; - - let entries = { - let content; - braced!(content in input); - - Punctuated::parse_terminated(&content)? - }; - - let _: Gt = input.parse()?; - - Ok(Self { - wrapper_ident, - struct_ident, - struct_generics: struct_generics.generics, - entries, - }) - } -} - -impl ToTokens for DelegateEntry -where - Type: ToTokens, -{ - fn to_tokens(&self, tokens: &mut TokenStream) { - let components = &self.keys; - let mode = &self.mode; - let source = &self.value; - - let count = components.len(); - - #[allow(clippy::comparison_chain)] - if count == 1 { - tokens.append_all(quote! { - #components #mode #source - }); - } else if count > 1 { - tokens.append_all(quote! { - [ - #components - ] #mode #source - }); - } - } -} - -impl ToTokens for DelegateKey -where - Type: ToTokens, -{ - fn to_tokens(&self, tokens: &mut TokenStream) { - tokens.extend(self.generics.to_token_stream()); - tokens.extend(self.ty.to_token_stream()); - } -} - -impl ToTokens for DelegateMode { - fn to_tokens(&self, tokens: &mut TokenStream) { - match self { - Self::Provider(colon) => colon.to_tokens(tokens), - Self::Direct(arrow) => arrow.to_tokens(tokens), - } - } -} - -impl ToTokens for DelegateValue { - fn to_tokens(&self, tokens: &mut TokenStream) { - match self { - Self::Type(value) => value.to_tokens(tokens), - Self::New(value) => value.to_tokens(tokens), - } - } -} - -impl ToTokens for DelegateNewValue { - fn to_tokens(&self, tokens: &mut TokenStream) { - let Self { - wrapper_ident, - struct_ident, - struct_generics, - entries, - } = self; - - tokens.extend(quote! { - #wrapper_ident < - new #struct_ident #struct_generics { - #entries - } - > - }); - } -} diff --git a/crates/macros/cgp-macro-lib/src/parse/mod.rs b/crates/macros/cgp-macro-lib/src/parse/mod.rs deleted file mode 100644 index ea12a5f9..00000000 --- a/crates/macros/cgp-macro-lib/src/parse/mod.rs +++ /dev/null @@ -1,9 +0,0 @@ -mod define_preset; -mod delegate_components; -mod path; -mod type_spec; - -pub use define_preset::*; -pub use delegate_components::*; -pub use path::*; -pub use type_spec::*; diff --git a/crates/macros/cgp-macro-lib/src/parse/path.rs b/crates/macros/cgp-macro-lib/src/parse/path.rs deleted file mode 100644 index 0f2a921f..00000000 --- a/crates/macros/cgp-macro-lib/src/parse/path.rs +++ /dev/null @@ -1,101 +0,0 @@ -use cgp_macro_core::types::generics::ImplGenerics; -use cgp_macro_core::types::path::PathHead; -use proc_macro2::TokenStream; -use quote::{ToTokens, quote}; -use syn::parse::{Parse, ParseStream}; -use syn::{Type, parse_quote}; - -pub struct ComponentPaths { - pub paths: Vec>, -} - -impl Parse for ComponentPaths { - fn parse(input: ParseStream) -> syn::Result { - let path_head = PathHead::parse(input)?; - - if let PathHead::End = path_head { - return Err(syn::Error::new( - input.span(), - "Expected at least one path element", - )); - } - - let mut paths = Vec::new(); - - for path in path_head_to_prefix(&path_head) { - let path_type: Type = syn::parse2(path.path_type)?; - paths.push(ComponentPath { - path_type, - generics: path.generics, - }); - } - - Ok(Self { paths }) - } -} - -#[derive(Clone)] -pub struct ComponentPath { - pub path_type: Path, - pub generics: ImplGenerics, -} - -pub fn path_head_to_prefix(path_head: &PathHead) -> Vec> { - match path_head { - PathHead::Type(path_element, rest) => { - let rest_types = path_head_to_prefix(rest); - - prepend_path( - path_element.element.to_token_stream(), - path_element.generics.clone(), - rest_types, - ) - } - PathHead::Group(path_elements, rest) => { - let rest_types = path_head_to_prefix(rest); - let mut out = Vec::new(); - - for path_element in path_elements { - let paths = prepend_path( - path_element.element.to_token_stream(), - path_element.generics.clone(), - rest_types.clone(), - ); - out.extend(paths); - } - - out - } - PathHead::Nested(paths) => paths.iter().flat_map(path_head_to_prefix).collect(), - PathHead::End => { - vec![ComponentPath { - path_type: quote! { __Wildcard__ }, - generics: parse_quote! { <__Wildcard__> }, - }] - } - } -} - -pub fn prepend_path( - path_type: TokenStream, - generics: ImplGenerics, - rest_types: Vec>, -) -> Vec> { - rest_types - .into_iter() - .map(|mut path| { - let rest_tokens = path.path_type; - - path.generics - .generics - .params - .extend(generics.generics.params.clone()); - - let new_path = quote! { PathCons< #path_type , #rest_tokens > }; - ComponentPath { - path_type: new_path, - generics: path.generics, - } - }) - .collect() -} diff --git a/crates/macros/cgp-macro-lib/src/parse/type_spec.rs b/crates/macros/cgp-macro-lib/src/parse/type_spec.rs deleted file mode 100644 index 285a96a9..00000000 --- a/crates/macros/cgp-macro-lib/src/parse/type_spec.rs +++ /dev/null @@ -1,30 +0,0 @@ -use cgp_macro_core::types::generics::ImplGenerics; -use quote::ToTokens; -use syn::Ident; -use syn::parse::{Parse, ParseStream}; -use syn::token::Lt; - -pub struct TypeSpec { - pub name: Ident, - pub generics: Option, -} - -impl Parse for TypeSpec { - fn parse(input: ParseStream) -> syn::Result { - let name: Ident = input.parse()?; - let generics = if input.peek(Lt) { - Some(input.parse()?) - } else { - None - }; - - Ok(Self { name, generics }) - } -} - -impl ToTokens for TypeSpec { - fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) { - self.name.to_tokens(tokens); - self.generics.to_tokens(tokens); - } -} diff --git a/crates/macros/cgp-macro-lib/src/preset/impl_is_preset.rs b/crates/macros/cgp-macro-lib/src/preset/impl_is_preset.rs deleted file mode 100644 index 72336da1..00000000 --- a/crates/macros/cgp-macro-lib/src/preset/impl_is_preset.rs +++ /dev/null @@ -1,43 +0,0 @@ -use alloc::vec::Vec; - -use cgp_macro_core::types::generics::ImplGenerics; -use cgp_macro_core::types::ident::IdentWithTypeArgs; -use syn::punctuated::Punctuated; -use syn::token::Comma; -use syn::{Ident, ItemImpl, Type, parse_quote}; - -use crate::parse::{DelegateEntry, DelegateKey}; - -pub fn impl_components_is_preset( - trait_name: &Ident, - preset_type: &Type, - preset_generics: &ImplGenerics, - delegate_entries: &Punctuated, Comma>, -) -> Vec { - delegate_entries - .iter() - .flat_map(|entry| { - entry.keys.iter().map(|component| { - impl_component_is_preset(trait_name, preset_type, preset_generics, component) - }) - }) - .collect() -} - -pub fn impl_component_is_preset( - trait_name: &Ident, - _preset_type: &Type, - _preset_generics: &ImplGenerics, - component: &DelegateKey, -) -> ItemImpl { - let component_type = &component.ty; - - let mut generics = component.generics.generics.clone(); - generics.params.push(parse_quote!(__Self__)); - - let impl_generics = generics.split_for_impl().0; - - parse_quote! { - impl #impl_generics #trait_name < #component_type > for __Self__ {} - } -} diff --git a/crates/macros/cgp-macro-lib/src/preset/mod.rs b/crates/macros/cgp-macro-lib/src/preset/mod.rs deleted file mode 100644 index 64e72093..00000000 --- a/crates/macros/cgp-macro-lib/src/preset/mod.rs +++ /dev/null @@ -1,5 +0,0 @@ -mod impl_is_preset; -mod substitution_macro; - -pub use impl_is_preset::*; -pub use substitution_macro::*; diff --git a/crates/macros/cgp-macro-lib/src/preset/substitution_macro.rs b/crates/macros/cgp-macro-lib/src/preset/substitution_macro.rs deleted file mode 100644 index b506e6df..00000000 --- a/crates/macros/cgp-macro-lib/src/preset/substitution_macro.rs +++ /dev/null @@ -1,18 +0,0 @@ -use proc_macro2::TokenStream; -use quote::quote; -use syn::Ident; - -pub fn define_substitution_macro(macro_name: &Ident, substitution: &TokenStream) -> TokenStream { - quote! { - #[macro_export] - #[doc(hidden)] - macro_rules! #macro_name { - ( $( $body:tt )* ) => { - replace_with! { - [ #substitution ], - $( $body )* - } - }; - } - } -} diff --git a/crates/macros/cgp-macro/src/lib.rs b/crates/macros/cgp-macro/src/lib.rs index 61cfb6d0..d85df306 100644 --- a/crates/macros/cgp-macro/src/lib.rs +++ b/crates/macros/cgp-macro/src/lib.rs @@ -624,90 +624,6 @@ pub fn delegate_and_check_components(body: TokenStream) -> TokenStream { .into() } -/** - CGP presets are made of extensible collection of key/value mappings, that can be inherited - to form new mappings. - - Instead of defining regular structs and build mappings with `delegate_components!`, - presets are constructed as _modules_ using the `cgp_preset!` macro together with the - `#[re_export_imports]`. For example, the same mappings earlier would be rewritten as: - - ```rust,ignore - #[cgp::re_export_imports] - mod preset { - use crate_a::{KeyA, ...}; - use crate_b::{ValueA, ...}; - - cgp_preset! { - PresetA { - KeyA: ValueA, - KeyB: ValueB, - KeyC: ValueC1, - } - } - } - ``` - - The `#[cgp::re_export_imports]` macro is used over a surrogate `mod preset`, which wraps - around the inner module to re-export the imports, so that they can be reused during the - merging. This is required, because the merging works through macros, which don't have access to the actual type information. Aside from that, the macro re-exports all exports from the inner module, so that we can write regular code as if the `mod preset` modifier never existed. - - The macro `cgp_preset!` works similar to `delegate_components!`, but it defines a new - _inner module_ that contains the mapping struct, together with macros and re-exports to - support the merging operation. - - Similarly, the second preset would be re-written as: - - ```rust,ignore - #[cgp::re_export_imports] - mod preset { - use crate_c::{KeyC, ...}; - use crate_d::{ValueD, ...}; - - cgp_preset! { - PresetB { - KeyC: ValueC2, - KeyD: ValueD, - KeyE: ValueE, - } - } - } - ``` - - To merge the two presets, we can define a new `PresetC` that _inherits_ from both `PresetA` - and `PresetB`, like follows: - - ```rust,ignore - #[cgp::re_export_imports] - mod preset { - use preset_a::PresetA; - use preset_b::PresetB; - use crate_f::{KeyF, ...}; - - cgp_preset! { - PresetC: PresetA + PresetB { - override KeyC: ValueC2, - KeyF: ValueF, - } - } - } - ``` - - As we can see, CGP supports *multiple inheritance* for presets by using macros to "copy" - over the entries from the parent preset. To resolve conflicts or override entries from - the parent presets, the `override` keyword can be used to exclude a given mapping from - being copied over and instead use the local definition. And since the underlying - implementation still uses `DelegateComponent` to implement the lookup, any non-overridden - conflicts would simply result in a trait error due to overlapping instances, thus preventing - the diamond inheritance dillema. -*/ -#[proc_macro] -pub fn cgp_preset(body: TokenStream) -> TokenStream { - cgp_macro_lib::define_preset(body.into()) - .unwrap_or_else(syn::Error::into_compile_error) - .into() -} - /** `#[cgp_type]` is an extension to [`#[cgp_component]`](macro@cgp_component) that derives additional constructs for abstract type components. @@ -781,41 +697,6 @@ pub fn cgp_type(attrs: TokenStream, body: TokenStream) -> TokenStream { .into() } -/** - The macro also allows the context provider to inherit its component mappings - from a specified preset. - - The context would implement `DelegateComponent` for all keys in the - preset, with the `Delegate` target pointing to `Preset::Provider`. This is - done through the `IsPreset` trait generated from the [`cgp_preset!`] macro. - - For example, given the following definition: - - ```rust,ignore - #[cgp_inherit(MyPreset)] - pub struct MyApp { - name: String, - } - ``` - - The following blanket implementation would be generated: - - ```rust,ignore - impl DelegateComponent for MyApp - where - Self: MyPreset::IsPreset, - { - type Delegate = MyPreset::Provider; - } - ``` -*/ -#[proc_macro_attribute] -pub fn cgp_inherit(attr: TokenStream, item: TokenStream) -> TokenStream { - cgp_macro_lib::cgp_inherit(attr.into(), item.into()) - .unwrap_or_else(syn::Error::into_compile_error) - .into() -} - /** The `#[blanket_trait]` macro can be used to define trait aliases that contain empty body and trivial blanket implementations. @@ -847,20 +728,6 @@ pub fn blanket_trait(attr: TokenStream, item: TokenStream) -> TokenStream { .into() } -#[proc_macro_attribute] -pub fn re_export_imports(attrs: TokenStream, body: TokenStream) -> TokenStream { - cgp_macro_lib::re_export_imports(attrs.into(), body.into()) - .unwrap_or_else(syn::Error::into_compile_error) - .into() -} - -#[proc_macro] -pub fn replace_with(body: TokenStream) -> TokenStream { - cgp_macro_lib::replace_with(body.into()) - .unwrap_or_else(syn::Error::into_compile_error) - .into() -} - /** The `Symbol!` macro is used to create a type-level string through the string literal given to the macro. diff --git a/crates/main/cgp-core/src/lib.rs b/crates/main/cgp-core/src/lib.rs index b9eeed7c..63d72983 100644 --- a/crates/main/cgp-core/src/lib.rs +++ b/crates/main/cgp-core/src/lib.rs @@ -7,5 +7,5 @@ pub use prelude as macro_prelude; #[doc(inline)] pub use { cgp_async_macro::async_trait, cgp_component as component, cgp_error as error, - cgp_field as field, cgp_macro as macros, cgp_macro::re_export_imports, cgp_type as types, + cgp_field as field, cgp_macro as macros, cgp_type as types, }; diff --git a/crates/main/cgp-core/src/prelude.rs b/crates/main/cgp-core/src/prelude.rs index 5702afab..59101d49 100644 --- a/crates/main/cgp-core/src/prelude.rs +++ b/crates/main/cgp-core/src/prelude.rs @@ -20,8 +20,7 @@ pub use cgp_field::types::{ pub use cgp_macro::{ BuildField, CgpData, CgpRecord, CgpVariant, ExtractField, FromVariant, HasField, HasFields, Product, Sum, Symbol, cgp_auto_getter, cgp_component, cgp_fn, cgp_getter, cgp_impl, - cgp_inherit, cgp_namespace, cgp_new_provider, cgp_preset, cgp_provider, cgp_type, - check_components, delegate_and_check_components, delegate_components, product, - re_export_imports, replace_with, + cgp_namespace, cgp_new_provider, cgp_provider, cgp_type, check_components, + delegate_and_check_components, delegate_components, product, }; pub use cgp_type::{HasType, TypeProvider, UseType}; diff --git a/crates/main/cgp/src/lib.rs b/crates/main/cgp/src/lib.rs index 1874b49f..08ca3427 100644 --- a/crates/main/cgp/src/lib.rs +++ b/crates/main/cgp/src/lib.rs @@ -2,7 +2,7 @@ #![doc = include_str!("../README.md")] #[doc(inline)] -pub use {cgp_core as core, cgp_core::re_export_imports, cgp_extra as extra}; +pub use {cgp_core as core, cgp_extra as extra}; pub mod prelude; diff --git a/crates/tests/cgp-tests/tests/component_tests/delegate_components/new_struct.rs b/crates/tests/cgp-tests/tests/component_tests/delegate_components/new_struct.rs index e0a4065f..5d38c106 100644 --- a/crates/tests/cgp-tests/tests/component_tests/delegate_components/new_struct.rs +++ b/crates/tests/cgp-tests/tests/component_tests/delegate_components/new_struct.rs @@ -127,38 +127,3 @@ pub fn test_delegate_new_with_array_key() { } } } - -pub mod test_delegate_new_value_in_preset { - #[cgp::re_export_imports] - mod preset { - use cgp::core::component::UseDelegate; - use cgp::prelude::{DelegateComponent, *}; - - pub struct FooKey; - pub struct FooValue; - pub struct BarKey; - pub struct BazKey; - pub struct BazValue; - - cgp_preset! { - PresetWithNewValue { - FooKey: FooValue, - BarKey: UseDelegate - } - } - - pub trait CheckDelegates: - DelegateComponent - + DelegateComponent> - { - } - - impl CheckDelegates for PresetWithNewValue::Provider {} - - pub trait CheckInnerDelegates: DelegateComponent {} - - impl CheckInnerDelegates for BarValue {} - } -} diff --git a/crates/tests/cgp-tests/tests/preset.rs b/crates/tests/cgp-tests/tests/preset.rs deleted file mode 100644 index 4dc60a54..00000000 --- a/crates/tests/cgp-tests/tests/preset.rs +++ /dev/null @@ -1,3 +0,0 @@ -#![allow(clippy::module_inception)] - -pub mod preset_tests; diff --git a/crates/tests/cgp-tests/tests/preset_tests/basic/components.rs b/crates/tests/cgp-tests/tests/preset_tests/basic/components.rs deleted file mode 100644 index 8b603884..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/basic/components.rs +++ /dev/null @@ -1,492 +0,0 @@ -use cgp::prelude::*; -use cgp_macro_test_util::{snapshot_cgp_getter, snapshot_cgp_type}; - -snapshot_cgp_type! { - #[cgp_type] - pub trait HasFooType { - type Foo; - } - - expand_has_foo_type(output) { - insta::assert_snapshot!(output, @" - pub trait HasFooType { - type Foo; - } - impl<__Context__> HasFooType for __Context__ - where - __Context__: FooTypeProvider<__Context__>, - { - type Foo = <__Context__ as FooTypeProvider<__Context__>>::Foo; - } - pub trait FooTypeProvider< - __Context__, - >: IsProviderFor { - type Foo; - } - impl<__Provider__, __Context__> FooTypeProvider<__Context__> for __Provider__ - where - __Provider__: DelegateComponent - + IsProviderFor, - <__Provider__ as DelegateComponent< - FooTypeProviderComponent, - >>::Delegate: FooTypeProvider<__Context__>, - { - type Foo = <<__Provider__ as DelegateComponent< - FooTypeProviderComponent, - >>::Delegate as FooTypeProvider<__Context__>>::Foo; - } - pub struct FooTypeProviderComponent; - impl<__Context__> FooTypeProvider<__Context__> for UseContext - where - __Context__: HasFooType, - { - type Foo = <__Context__ as HasFooType>::Foo; - } - impl<__Context__> IsProviderFor for UseContext - where - __Context__: HasFooType, - {} - impl<__Context__, __Components__, __Path__> FooTypeProvider<__Context__> - for RedirectLookup<__Components__, __Path__> - where - __Components__: DelegateComponent<__Path__>, - <__Components__ as DelegateComponent< - __Path__, - >>::Delegate: FooTypeProvider<__Context__>, - { - type Foo = <<__Components__ as DelegateComponent< - __Path__, - >>::Delegate as FooTypeProvider<__Context__>>::Foo; - } - impl< - __Context__, - __Components__, - __Path__, - > IsProviderFor - for RedirectLookup<__Components__, __Path__> - where - __Components__: DelegateComponent<__Path__>, - <__Components__ as DelegateComponent< - __Path__, - >>::Delegate: IsProviderFor - + FooTypeProvider<__Context__>, - {} - impl FooTypeProvider<__Context__> for UseType - where - Foo:, - { - type Foo = Foo; - } - impl IsProviderFor - for UseType - where - Foo:, - {} - impl<__Provider__, Foo, __Context__> FooTypeProvider<__Context__> - for WithProvider<__Provider__> - where - __Provider__: TypeProvider<__Context__, FooTypeProviderComponent, Type = Foo>, - Foo:, - { - type Foo = Foo; - } - impl< - __Provider__, - Foo, - __Context__, - > IsProviderFor for WithProvider<__Provider__> - where - __Provider__: TypeProvider<__Context__, FooTypeProviderComponent, Type = Foo>, - Foo:, - {} - ") - } -} - -snapshot_cgp_type! { - #[cgp_type] - pub trait HasBarType { - type Bar; - } - - expand_has_bar_type(output) { - insta::assert_snapshot!(output, @" - pub trait HasBarType { - type Bar; - } - impl<__Context__> HasBarType for __Context__ - where - __Context__: BarTypeProvider<__Context__>, - { - type Bar = <__Context__ as BarTypeProvider<__Context__>>::Bar; - } - pub trait BarTypeProvider< - __Context__, - >: IsProviderFor { - type Bar; - } - impl<__Provider__, __Context__> BarTypeProvider<__Context__> for __Provider__ - where - __Provider__: DelegateComponent - + IsProviderFor, - <__Provider__ as DelegateComponent< - BarTypeProviderComponent, - >>::Delegate: BarTypeProvider<__Context__>, - { - type Bar = <<__Provider__ as DelegateComponent< - BarTypeProviderComponent, - >>::Delegate as BarTypeProvider<__Context__>>::Bar; - } - pub struct BarTypeProviderComponent; - impl<__Context__> BarTypeProvider<__Context__> for UseContext - where - __Context__: HasBarType, - { - type Bar = <__Context__ as HasBarType>::Bar; - } - impl<__Context__> IsProviderFor for UseContext - where - __Context__: HasBarType, - {} - impl<__Context__, __Components__, __Path__> BarTypeProvider<__Context__> - for RedirectLookup<__Components__, __Path__> - where - __Components__: DelegateComponent<__Path__>, - <__Components__ as DelegateComponent< - __Path__, - >>::Delegate: BarTypeProvider<__Context__>, - { - type Bar = <<__Components__ as DelegateComponent< - __Path__, - >>::Delegate as BarTypeProvider<__Context__>>::Bar; - } - impl< - __Context__, - __Components__, - __Path__, - > IsProviderFor - for RedirectLookup<__Components__, __Path__> - where - __Components__: DelegateComponent<__Path__>, - <__Components__ as DelegateComponent< - __Path__, - >>::Delegate: IsProviderFor - + BarTypeProvider<__Context__>, - {} - impl BarTypeProvider<__Context__> for UseType - where - Bar:, - { - type Bar = Bar; - } - impl IsProviderFor - for UseType - where - Bar:, - {} - impl<__Provider__, Bar, __Context__> BarTypeProvider<__Context__> - for WithProvider<__Provider__> - where - __Provider__: TypeProvider<__Context__, BarTypeProviderComponent, Type = Bar>, - Bar:, - { - type Bar = Bar; - } - impl< - __Provider__, - Bar, - __Context__, - > IsProviderFor for WithProvider<__Provider__> - where - __Provider__: TypeProvider<__Context__, BarTypeProviderComponent, Type = Bar>, - Bar:, - {} - ") - } -} - -snapshot_cgp_getter! { - #[cgp_getter] - pub trait HasFoo: HasFooType { - fn foo(&self) -> &Self::Foo; - } - - expand_has_foo(output) { - insta::assert_snapshot!(output, @" - pub trait HasFoo: HasFooType { - fn foo(&self) -> &Self::Foo; - } - impl<__Context__> HasFoo for __Context__ - where - __Context__: HasFooType, - __Context__: FooGetter<__Context__>, - { - fn foo(&self) -> &Self::Foo { - __Context__::foo(self) - } - } - pub trait FooGetter<__Context__>: IsProviderFor - where - __Context__: HasFooType, - { - fn foo(__context__: &__Context__) -> &__Context__::Foo; - } - impl<__Provider__, __Context__> FooGetter<__Context__> for __Provider__ - where - __Context__: HasFooType, - __Provider__: DelegateComponent - + IsProviderFor, - <__Provider__ as DelegateComponent< - FooGetterComponent, - >>::Delegate: FooGetter<__Context__>, - { - fn foo(__context__: &__Context__) -> &__Context__::Foo { - <__Provider__ as DelegateComponent< - FooGetterComponent, - >>::Delegate::foo(__context__) - } - } - pub struct FooGetterComponent; - impl<__Context__> FooGetter<__Context__> for UseContext - where - __Context__: HasFooType, - __Context__: HasFoo, - { - fn foo(__context__: &__Context__) -> &__Context__::Foo { - __Context__::foo(__context__) - } - } - impl<__Context__> IsProviderFor for UseContext - where - __Context__: HasFooType, - __Context__: HasFoo, - {} - impl<__Context__, __Components__, __Path__> FooGetter<__Context__> - for RedirectLookup<__Components__, __Path__> - where - __Context__: HasFooType, - __Components__: DelegateComponent<__Path__>, - <__Components__ as DelegateComponent<__Path__>>::Delegate: FooGetter<__Context__>, - { - fn foo(__context__: &__Context__) -> &__Context__::Foo { - <__Components__ as DelegateComponent<__Path__>>::Delegate::foo(__context__) - } - } - impl< - __Context__, - __Components__, - __Path__, - > IsProviderFor - for RedirectLookup<__Components__, __Path__> - where - __Context__: HasFooType, - __Components__: DelegateComponent<__Path__>, - <__Components__ as DelegateComponent< - __Path__, - >>::Delegate: IsProviderFor - + FooGetter<__Context__>, - {} - impl<__Context__> FooGetter<__Context__> for UseFields - where - __Context__: HasFooType, - __Context__: HasField< - Symbol<3, Chars<'f', Chars<'o', Chars<'o', Nil>>>>, - Value = __Context__::Foo, - >, - { - fn foo(__context__: &__Context__) -> &__Context__::Foo { - __context__ - .get_field( - ::core::marker::PhantomData::< - Symbol<3, Chars<'f', Chars<'o', Chars<'o', Nil>>>>, - >, - ) - } - } - impl<__Context__> IsProviderFor for UseFields - where - __Context__: HasFooType, - __Context__: HasField< - Symbol<3, Chars<'f', Chars<'o', Chars<'o', Nil>>>>, - Value = __Context__::Foo, - >, - {} - impl<__Context__, __Tag__> FooGetter<__Context__> for UseField<__Tag__> - where - __Context__: HasFooType, - __Context__: HasField<__Tag__, Value = __Context__::Foo>, - { - fn foo(__context__: &__Context__) -> &__Context__::Foo { - __context__.get_field(::core::marker::PhantomData::<__Tag__>) - } - } - impl<__Context__, __Tag__> IsProviderFor - for UseField<__Tag__> - where - __Context__: HasFooType, - __Context__: HasField<__Tag__, Value = __Context__::Foo>, - {} - impl<__Context__, __Provider__> FooGetter<__Context__> for WithProvider<__Provider__> - where - __Context__: HasFooType, - __Provider__: FieldGetter<__Context__, FooGetterComponent, Value = __Context__::Foo>, - { - fn foo(__context__: &__Context__) -> &__Context__::Foo { - __Provider__::get_field( - __context__, - ::core::marker::PhantomData::, - ) - } - } - impl<__Context__, __Provider__> IsProviderFor - for WithProvider<__Provider__> - where - __Context__: HasFooType, - __Provider__: FieldGetter<__Context__, FooGetterComponent, Value = __Context__::Foo>, - {} - ") - } -} - -snapshot_cgp_getter! { - #[cgp_getter] - pub trait HasBar: HasBarType { - fn bar(&self) -> &Self::Bar; - } - - expand_has_bar(output) { - insta::assert_snapshot!(output, @" - pub trait HasBar: HasBarType { - fn bar(&self) -> &Self::Bar; - } - impl<__Context__> HasBar for __Context__ - where - __Context__: HasBarType, - __Context__: BarGetter<__Context__>, - { - fn bar(&self) -> &Self::Bar { - __Context__::bar(self) - } - } - pub trait BarGetter<__Context__>: IsProviderFor - where - __Context__: HasBarType, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar; - } - impl<__Provider__, __Context__> BarGetter<__Context__> for __Provider__ - where - __Context__: HasBarType, - __Provider__: DelegateComponent - + IsProviderFor, - <__Provider__ as DelegateComponent< - BarGetterComponent, - >>::Delegate: BarGetter<__Context__>, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar { - <__Provider__ as DelegateComponent< - BarGetterComponent, - >>::Delegate::bar(__context__) - } - } - pub struct BarGetterComponent; - impl<__Context__> BarGetter<__Context__> for UseContext - where - __Context__: HasBarType, - __Context__: HasBar, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar { - __Context__::bar(__context__) - } - } - impl<__Context__> IsProviderFor for UseContext - where - __Context__: HasBarType, - __Context__: HasBar, - {} - impl<__Context__, __Components__, __Path__> BarGetter<__Context__> - for RedirectLookup<__Components__, __Path__> - where - __Context__: HasBarType, - __Components__: DelegateComponent<__Path__>, - <__Components__ as DelegateComponent<__Path__>>::Delegate: BarGetter<__Context__>, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar { - <__Components__ as DelegateComponent<__Path__>>::Delegate::bar(__context__) - } - } - impl< - __Context__, - __Components__, - __Path__, - > IsProviderFor - for RedirectLookup<__Components__, __Path__> - where - __Context__: HasBarType, - __Components__: DelegateComponent<__Path__>, - <__Components__ as DelegateComponent< - __Path__, - >>::Delegate: IsProviderFor - + BarGetter<__Context__>, - {} - impl<__Context__> BarGetter<__Context__> for UseFields - where - __Context__: HasBarType, - __Context__: HasField< - Symbol<3, Chars<'b', Chars<'a', Chars<'r', Nil>>>>, - Value = __Context__::Bar, - >, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar { - __context__ - .get_field( - ::core::marker::PhantomData::< - Symbol<3, Chars<'b', Chars<'a', Chars<'r', Nil>>>>, - >, - ) - } - } - impl<__Context__> IsProviderFor for UseFields - where - __Context__: HasBarType, - __Context__: HasField< - Symbol<3, Chars<'b', Chars<'a', Chars<'r', Nil>>>>, - Value = __Context__::Bar, - >, - {} - impl<__Context__, __Tag__> BarGetter<__Context__> for UseField<__Tag__> - where - __Context__: HasBarType, - __Context__: HasField<__Tag__, Value = __Context__::Bar>, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar { - __context__.get_field(::core::marker::PhantomData::<__Tag__>) - } - } - impl<__Context__, __Tag__> IsProviderFor - for UseField<__Tag__> - where - __Context__: HasBarType, - __Context__: HasField<__Tag__, Value = __Context__::Bar>, - {} - impl<__Context__, __Provider__> BarGetter<__Context__> for WithProvider<__Provider__> - where - __Context__: HasBarType, - __Provider__: FieldGetter<__Context__, BarGetterComponent, Value = __Context__::Bar>, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar { - __Provider__::get_field( - __context__, - ::core::marker::PhantomData::, - ) - } - } - impl<__Context__, __Provider__> IsProviderFor - for WithProvider<__Provider__> - where - __Context__: HasBarType, - __Provider__: FieldGetter<__Context__, BarGetterComponent, Value = __Context__::Bar>, - {} - ") - } -} diff --git a/crates/tests/cgp-tests/tests/preset_tests/basic/consumer_delegate.rs b/crates/tests/cgp-tests/tests/preset_tests/basic/consumer_delegate.rs deleted file mode 100644 index b65926c9..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/basic/consumer_delegate.rs +++ /dev/null @@ -1,44 +0,0 @@ -use cgp::prelude::*; -use cgp_macro_test_util::snapshot_check_components; - -use crate::preset_tests::basic::components::{ - BarTypeProviderComponent, FooGetterComponent, FooTypeProviderComponent, HasBar, -}; -use crate::preset_tests::basic::preset::{CheckDelegatesForMyPreset, MyPreset}; - -#[cgp_inherit(MyPreset)] -#[derive(HasField)] -pub struct MyContext { - pub foo: (), - pub bar: (), -} - -impl HasBar for MyContext { - fn bar(&self) -> &Self::Bar { - &self.bar - } -} - -snapshot_check_components! { - check_components! { - MyContext { - FooTypeProviderComponent, - BarTypeProviderComponent, - FooGetterComponent, - } - } - - expand_check_my_context(output) { - insta::assert_snapshot!(output, @" - trait __CheckMyContext< - __Component__, - __Params__: ?Sized, - >: CanUseComponent<__Component__, __Params__> {} - impl __CheckMyContext for MyContext {} - impl __CheckMyContext for MyContext {} - impl __CheckMyContext for MyContext {} - ") - } -} - -impl CheckDelegatesForMyPreset for MyContext {} diff --git a/crates/tests/cgp-tests/tests/preset_tests/basic/contexts.rs b/crates/tests/cgp-tests/tests/preset_tests/basic/contexts.rs deleted file mode 100644 index bd379bbf..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/basic/contexts.rs +++ /dev/null @@ -1,61 +0,0 @@ -use cgp::prelude::*; -use cgp_macro_test_util::{snapshot_check_components, snapshot_delegate_components}; - -use crate::preset_tests::basic::components::{ - BarGetterComponent, BarTypeProviderComponent, FooGetterComponent, FooTypeProviderComponent, -}; -use crate::preset_tests::basic::preset::{CheckDelegatesForMyPreset, MyPreset}; - -#[cgp_inherit(MyPreset)] -#[derive(HasField)] -pub struct MyContext { - pub foo: (), - pub bar: (), -} - -snapshot_delegate_components! { - delegate_components! { - MyContext { - BarGetterComponent: UseField, - } - } - - expand_my_context(output) { - insta::assert_snapshot!(output, @r#" - impl DelegateComponent for MyContext { - type Delegate = UseField; - } - impl<__Context__, __Params__> IsProviderFor - for MyContext - where - UseField: IsProviderFor, - {} - "#) - } -} - -snapshot_check_components! { - check_components! { - MyContext { - FooTypeProviderComponent, - BarTypeProviderComponent, - FooGetterComponent, - BarGetterComponent, - } - } - - expand_check_my_context(output) { - insta::assert_snapshot!(output, @" - trait __CheckMyContext< - __Component__, - __Params__: ?Sized, - >: CanUseComponent<__Component__, __Params__> {} - impl __CheckMyContext for MyContext {} - impl __CheckMyContext for MyContext {} - impl __CheckMyContext for MyContext {} - impl __CheckMyContext for MyContext {} - ") - } -} - -impl CheckDelegatesForMyPreset for MyContext {} diff --git a/crates/tests/cgp-tests/tests/preset_tests/basic/mod.rs b/crates/tests/cgp-tests/tests/preset_tests/basic/mod.rs deleted file mode 100644 index 9f6ff9b2..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/basic/mod.rs +++ /dev/null @@ -1,4 +0,0 @@ -pub mod components; -pub mod consumer_delegate; -pub mod contexts; -pub mod preset; diff --git a/crates/tests/cgp-tests/tests/preset_tests/basic/preset.rs b/crates/tests/cgp-tests/tests/preset_tests/basic/preset.rs deleted file mode 100644 index 15c09117..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/basic/preset.rs +++ /dev/null @@ -1,29 +0,0 @@ -#[cgp::re_export_imports] -mod preset { - use cgp::prelude::*; - - use crate::preset_tests::basic::components::{ - BarTypeProviderComponent, FooGetterComponent, FooTypeProviderComponent, - }; - - cgp_preset! { - MyPreset { - [ - FooTypeProviderComponent, - BarTypeProviderComponent, - ]: - UseType<()>, - FooGetterComponent: - UseField, - } - } - - pub trait CheckDelegatesForMyPreset: - DelegateComponent> - + DelegateComponent> - + DelegateComponent> - { - } - - impl CheckDelegatesForMyPreset for MyPreset::Provider {} -} diff --git a/crates/tests/cgp-tests/tests/preset_tests/generics/components.rs b/crates/tests/cgp-tests/tests/preset_tests/generics/components.rs deleted file mode 100644 index 4ff6ecf2..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/generics/components.rs +++ /dev/null @@ -1,523 +0,0 @@ -use core::marker::PhantomData; - -use cgp::prelude::*; -use cgp_macro_test_util::{snapshot_cgp_getter, snapshot_cgp_type}; - -snapshot_cgp_type! { - #[cgp_type] - pub trait HasFooType { - type Foo; - } - - expand_has_foo_type(output) { - insta::assert_snapshot!(output, @" - pub trait HasFooType { - type Foo; - } - impl<__Context__> HasFooType for __Context__ - where - __Context__: FooTypeProvider<__Context__>, - { - type Foo = <__Context__ as FooTypeProvider<__Context__>>::Foo; - } - pub trait FooTypeProvider< - __Context__, - >: IsProviderFor { - type Foo; - } - impl<__Provider__, __Context__> FooTypeProvider<__Context__> for __Provider__ - where - __Provider__: DelegateComponent - + IsProviderFor, - <__Provider__ as DelegateComponent< - FooTypeProviderComponent, - >>::Delegate: FooTypeProvider<__Context__>, - { - type Foo = <<__Provider__ as DelegateComponent< - FooTypeProviderComponent, - >>::Delegate as FooTypeProvider<__Context__>>::Foo; - } - pub struct FooTypeProviderComponent; - impl<__Context__> FooTypeProvider<__Context__> for UseContext - where - __Context__: HasFooType, - { - type Foo = <__Context__ as HasFooType>::Foo; - } - impl<__Context__> IsProviderFor for UseContext - where - __Context__: HasFooType, - {} - impl<__Context__, __Components__, __Path__> FooTypeProvider<__Context__> - for RedirectLookup<__Components__, __Path__> - where - __Components__: DelegateComponent<__Path__>, - <__Components__ as DelegateComponent< - __Path__, - >>::Delegate: FooTypeProvider<__Context__>, - { - type Foo = <<__Components__ as DelegateComponent< - __Path__, - >>::Delegate as FooTypeProvider<__Context__>>::Foo; - } - impl< - __Context__, - __Components__, - __Path__, - > IsProviderFor - for RedirectLookup<__Components__, __Path__> - where - __Components__: DelegateComponent<__Path__>, - <__Components__ as DelegateComponent< - __Path__, - >>::Delegate: IsProviderFor - + FooTypeProvider<__Context__>, - {} - impl FooTypeProvider<__Context__> for UseType - where - Foo:, - { - type Foo = Foo; - } - impl IsProviderFor - for UseType - where - Foo:, - {} - impl<__Provider__, Foo, __Context__> FooTypeProvider<__Context__> - for WithProvider<__Provider__> - where - __Provider__: TypeProvider<__Context__, FooTypeProviderComponent, Type = Foo>, - Foo:, - { - type Foo = Foo; - } - impl< - __Provider__, - Foo, - __Context__, - > IsProviderFor for WithProvider<__Provider__> - where - __Provider__: TypeProvider<__Context__, FooTypeProviderComponent, Type = Foo>, - Foo:, - {} - ") - } -} - -snapshot_cgp_type! { - #[cgp_type] - pub trait HasBarType { - type Bar; - } - - expand_has_bar_type(output) { - insta::assert_snapshot!(output, @" - pub trait HasBarType { - type Bar; - } - impl<__Context__> HasBarType for __Context__ - where - __Context__: BarTypeProvider<__Context__>, - { - type Bar = <__Context__ as BarTypeProvider<__Context__>>::Bar; - } - pub trait BarTypeProvider< - __Context__, - >: IsProviderFor { - type Bar; - } - impl<__Provider__, __Context__> BarTypeProvider<__Context__> for __Provider__ - where - __Provider__: DelegateComponent - + IsProviderFor, - <__Provider__ as DelegateComponent< - BarTypeProviderComponent, - >>::Delegate: BarTypeProvider<__Context__>, - { - type Bar = <<__Provider__ as DelegateComponent< - BarTypeProviderComponent, - >>::Delegate as BarTypeProvider<__Context__>>::Bar; - } - pub struct BarTypeProviderComponent; - impl<__Context__> BarTypeProvider<__Context__> for UseContext - where - __Context__: HasBarType, - { - type Bar = <__Context__ as HasBarType>::Bar; - } - impl<__Context__> IsProviderFor for UseContext - where - __Context__: HasBarType, - {} - impl<__Context__, __Components__, __Path__> BarTypeProvider<__Context__> - for RedirectLookup<__Components__, __Path__> - where - __Components__: DelegateComponent<__Path__>, - <__Components__ as DelegateComponent< - __Path__, - >>::Delegate: BarTypeProvider<__Context__>, - { - type Bar = <<__Components__ as DelegateComponent< - __Path__, - >>::Delegate as BarTypeProvider<__Context__>>::Bar; - } - impl< - __Context__, - __Components__, - __Path__, - > IsProviderFor - for RedirectLookup<__Components__, __Path__> - where - __Components__: DelegateComponent<__Path__>, - <__Components__ as DelegateComponent< - __Path__, - >>::Delegate: IsProviderFor - + BarTypeProvider<__Context__>, - {} - impl BarTypeProvider<__Context__> for UseType - where - Bar:, - { - type Bar = Bar; - } - impl IsProviderFor - for UseType - where - Bar:, - {} - impl<__Provider__, Bar, __Context__> BarTypeProvider<__Context__> - for WithProvider<__Provider__> - where - __Provider__: TypeProvider<__Context__, BarTypeProviderComponent, Type = Bar>, - Bar:, - { - type Bar = Bar; - } - impl< - __Provider__, - Bar, - __Context__, - > IsProviderFor for WithProvider<__Provider__> - where - __Provider__: TypeProvider<__Context__, BarTypeProviderComponent, Type = Bar>, - Bar:, - {} - ") - } -} - -snapshot_cgp_getter! { - #[cgp_getter { - name: FooGetterComponent, - provider: FooGetter, - }] - pub trait HasFooAt: HasFooType { - fn foo(&self, _tag: PhantomData) -> &Self::Foo; - } - - expand_has_foo_at(output) { - insta::assert_snapshot!(output, @" - pub trait HasFooAt: HasFooType { - fn foo(&self, _tag: PhantomData) -> &Self::Foo; - } - impl<__Context__, I> HasFooAt for __Context__ - where - __Context__: HasFooType, - __Context__: FooGetter<__Context__, I>, - { - fn foo(&self, _tag: PhantomData) -> &Self::Foo { - __Context__::foo(self, _tag) - } - } - pub trait FooGetter< - __Context__, - I, - >: IsProviderFor, __Context__, (I)> - where - __Context__: HasFooType, - { - fn foo(__context__: &__Context__, _tag: PhantomData) -> &__Context__::Foo; - } - impl<__Provider__, __Context__, I> FooGetter<__Context__, I> for __Provider__ - where - __Context__: HasFooType, - __Provider__: DelegateComponent> - + IsProviderFor, __Context__, (I)>, - <__Provider__ as DelegateComponent< - FooGetterComponent, - >>::Delegate: FooGetter<__Context__, I>, - { - fn foo(__context__: &__Context__, _tag: PhantomData) -> &__Context__::Foo { - <__Provider__ as DelegateComponent< - FooGetterComponent, - >>::Delegate::foo(__context__, _tag) - } - } - pub struct FooGetterComponent(pub ::core::marker::PhantomData<(I)>); - impl<__Context__, I> FooGetter<__Context__, I> for UseContext - where - __Context__: HasFooType, - __Context__: HasFooAt, - { - fn foo(__context__: &__Context__, _tag: PhantomData) -> &__Context__::Foo { - __Context__::foo(__context__, _tag) - } - } - impl<__Context__, I> IsProviderFor, __Context__, (I)> - for UseContext - where - __Context__: HasFooType, - __Context__: HasFooAt, - {} - impl<__Context__, I, __Components__, __Path__> FooGetter<__Context__, I> - for RedirectLookup<__Components__, __Path__> - where - __Context__: HasFooType, - __Path__: ConcatPath>, - __Components__: DelegateComponent< - <__Path__ as ConcatPath>>::Output, - >, - <__Components__ as DelegateComponent< - <__Path__ as ConcatPath>>::Output, - >>::Delegate: FooGetter<__Context__, I>, - { - fn foo(__context__: &__Context__, _tag: PhantomData) -> &__Context__::Foo { - <__Components__ as DelegateComponent< - <__Path__ as ConcatPath>>::Output, - >>::Delegate::foo(__context__, _tag) - } - } - impl< - __Context__, - I, - __Components__, - __Path__, - > IsProviderFor, __Context__, (I)> - for RedirectLookup<__Components__, __Path__> - where - __Context__: HasFooType, - __Path__: ConcatPath>, - __Components__: DelegateComponent< - <__Path__ as ConcatPath>>::Output, - >, - <__Components__ as DelegateComponent< - <__Path__ as ConcatPath>>::Output, - >>::Delegate: IsProviderFor, __Context__, (I)> - + FooGetter<__Context__, I>, - {} - impl<__Context__, I> FooGetter<__Context__, I> for UseFields - where - __Context__: HasFooType, - __Context__: HasField< - Symbol<3, Chars<'f', Chars<'o', Chars<'o', Nil>>>>, - Value = __Context__::Foo, - >, - { - fn foo(__context__: &__Context__, _phantom: PhantomData) -> &__Context__::Foo { - __context__ - .get_field( - ::core::marker::PhantomData::< - Symbol<3, Chars<'f', Chars<'o', Chars<'o', Nil>>>>, - >, - ) - } - } - impl<__Context__, I> IsProviderFor, __Context__, (I)> for UseFields - where - __Context__: HasFooType, - __Context__: HasField< - Symbol<3, Chars<'f', Chars<'o', Chars<'o', Nil>>>>, - Value = __Context__::Foo, - >, - {} - impl<__Context__, I, __Tag__> FooGetter<__Context__, I> for UseField<__Tag__> - where - __Context__: HasFooType, - __Context__: HasField<__Tag__, Value = __Context__::Foo>, - { - fn foo(__context__: &__Context__, _phantom: PhantomData) -> &__Context__::Foo { - __context__.get_field(::core::marker::PhantomData::<__Tag__>) - } - } - impl<__Context__, I, __Tag__> IsProviderFor, __Context__, (I)> - for UseField<__Tag__> - where - __Context__: HasFooType, - __Context__: HasField<__Tag__, Value = __Context__::Foo>, - {} - impl<__Context__, I, __Provider__> FooGetter<__Context__, I> - for WithProvider<__Provider__> - where - __Context__: HasFooType, - __Provider__: FieldGetter< - __Context__, - FooGetterComponent, - Value = __Context__::Foo, - >, - { - fn foo(__context__: &__Context__, _phantom: PhantomData) -> &__Context__::Foo { - __Provider__::get_field( - __context__, - ::core::marker::PhantomData::>, - ) - } - } - impl<__Context__, I, __Provider__> IsProviderFor, __Context__, (I)> - for WithProvider<__Provider__> - where - __Context__: HasFooType, - __Provider__: FieldGetter< - __Context__, - FooGetterComponent, - Value = __Context__::Foo, - >, - {} - ") - } -} - -snapshot_cgp_getter! { - #[cgp_getter { - provider: BarGetter, - }] - pub trait HasBar: HasBarType { - fn bar(&self) -> &Self::Bar; - } - - expand_has_bar(output) { - insta::assert_snapshot!(output, @" - pub trait HasBar: HasBarType { - fn bar(&self) -> &Self::Bar; - } - impl<__Context__> HasBar for __Context__ - where - __Context__: HasBarType, - __Context__: BarGetter<__Context__>, - { - fn bar(&self) -> &Self::Bar { - __Context__::bar(self) - } - } - pub trait BarGetter<__Context__>: IsProviderFor - where - __Context__: HasBarType, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar; - } - impl<__Provider__, __Context__> BarGetter<__Context__> for __Provider__ - where - __Context__: HasBarType, - __Provider__: DelegateComponent - + IsProviderFor, - <__Provider__ as DelegateComponent< - BarGetterComponent, - >>::Delegate: BarGetter<__Context__>, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar { - <__Provider__ as DelegateComponent< - BarGetterComponent, - >>::Delegate::bar(__context__) - } - } - pub struct BarGetterComponent; - impl<__Context__> BarGetter<__Context__> for UseContext - where - __Context__: HasBarType, - __Context__: HasBar, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar { - __Context__::bar(__context__) - } - } - impl<__Context__> IsProviderFor for UseContext - where - __Context__: HasBarType, - __Context__: HasBar, - {} - impl<__Context__, __Components__, __Path__> BarGetter<__Context__> - for RedirectLookup<__Components__, __Path__> - where - __Context__: HasBarType, - __Components__: DelegateComponent<__Path__>, - <__Components__ as DelegateComponent<__Path__>>::Delegate: BarGetter<__Context__>, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar { - <__Components__ as DelegateComponent<__Path__>>::Delegate::bar(__context__) - } - } - impl< - __Context__, - __Components__, - __Path__, - > IsProviderFor - for RedirectLookup<__Components__, __Path__> - where - __Context__: HasBarType, - __Components__: DelegateComponent<__Path__>, - <__Components__ as DelegateComponent< - __Path__, - >>::Delegate: IsProviderFor - + BarGetter<__Context__>, - {} - impl<__Context__> BarGetter<__Context__> for UseFields - where - __Context__: HasBarType, - __Context__: HasField< - Symbol<3, Chars<'b', Chars<'a', Chars<'r', Nil>>>>, - Value = __Context__::Bar, - >, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar { - __context__ - .get_field( - ::core::marker::PhantomData::< - Symbol<3, Chars<'b', Chars<'a', Chars<'r', Nil>>>>, - >, - ) - } - } - impl<__Context__> IsProviderFor for UseFields - where - __Context__: HasBarType, - __Context__: HasField< - Symbol<3, Chars<'b', Chars<'a', Chars<'r', Nil>>>>, - Value = __Context__::Bar, - >, - {} - impl<__Context__, __Tag__> BarGetter<__Context__> for UseField<__Tag__> - where - __Context__: HasBarType, - __Context__: HasField<__Tag__, Value = __Context__::Bar>, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar { - __context__.get_field(::core::marker::PhantomData::<__Tag__>) - } - } - impl<__Context__, __Tag__> IsProviderFor - for UseField<__Tag__> - where - __Context__: HasBarType, - __Context__: HasField<__Tag__, Value = __Context__::Bar>, - {} - impl<__Context__, __Provider__> BarGetter<__Context__> for WithProvider<__Provider__> - where - __Context__: HasBarType, - __Provider__: FieldGetter<__Context__, BarGetterComponent, Value = __Context__::Bar>, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar { - __Provider__::get_field( - __context__, - ::core::marker::PhantomData::, - ) - } - } - impl<__Context__, __Provider__> IsProviderFor - for WithProvider<__Provider__> - where - __Context__: HasBarType, - __Provider__: FieldGetter<__Context__, BarGetterComponent, Value = __Context__::Bar>, - {} - ") - } -} diff --git a/crates/tests/cgp-tests/tests/preset_tests/generics/consumer_delegate.rs b/crates/tests/cgp-tests/tests/preset_tests/generics/consumer_delegate.rs deleted file mode 100644 index 4515d852..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/generics/consumer_delegate.rs +++ /dev/null @@ -1,57 +0,0 @@ -use cgp::prelude::*; -use cgp_macro_test_util::snapshot_check_components; - -use crate::preset_tests::generics::components::{ - BarGetterComponent, BarTypeProviderComponent, FooGetterComponent, FooTypeProviderComponent, -}; -use crate::preset_tests::generics::preset::MyGenericPreset; - -#[cgp_inherit(MyGenericPreset)] -#[derive(HasField)] -pub struct MyContext { - pub foo: T, - pub bar: T, -} - -snapshot_check_components! { - check_components! { - #[check_trait(CanUseMyContext)] - MyContext { - FooTypeProviderComponent, - BarTypeProviderComponent, - BarGetterComponent, - } - } - - expand_check_my_context(output) { - insta::assert_snapshot!(output, @" - trait CanUseMyContext< - __Component__, - __Params__: ?Sized, - >: CanUseComponent<__Component__, __Params__> {} - impl CanUseMyContext for MyContext {} - impl CanUseMyContext for MyContext {} - impl CanUseMyContext for MyContext {} - ") - } -} - -snapshot_check_components! { - check_components! { - #[check_trait(CanUseFooGetter)] - MyContext { - FooGetterComponent>: Index, - } - } - - expand_check_my_context_2(output) { - insta::assert_snapshot!(output, @" - trait CanUseFooGetter< - __Component__, - __Params__: ?Sized, - >: CanUseComponent<__Component__, __Params__> {} - impl CanUseFooGetter>, Index> - for MyContext {} - ") - } -} diff --git a/crates/tests/cgp-tests/tests/preset_tests/generics/contexts.rs b/crates/tests/cgp-tests/tests/preset_tests/generics/contexts.rs deleted file mode 100644 index 4515d852..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/generics/contexts.rs +++ /dev/null @@ -1,57 +0,0 @@ -use cgp::prelude::*; -use cgp_macro_test_util::snapshot_check_components; - -use crate::preset_tests::generics::components::{ - BarGetterComponent, BarTypeProviderComponent, FooGetterComponent, FooTypeProviderComponent, -}; -use crate::preset_tests::generics::preset::MyGenericPreset; - -#[cgp_inherit(MyGenericPreset)] -#[derive(HasField)] -pub struct MyContext { - pub foo: T, - pub bar: T, -} - -snapshot_check_components! { - check_components! { - #[check_trait(CanUseMyContext)] - MyContext { - FooTypeProviderComponent, - BarTypeProviderComponent, - BarGetterComponent, - } - } - - expand_check_my_context(output) { - insta::assert_snapshot!(output, @" - trait CanUseMyContext< - __Component__, - __Params__: ?Sized, - >: CanUseComponent<__Component__, __Params__> {} - impl CanUseMyContext for MyContext {} - impl CanUseMyContext for MyContext {} - impl CanUseMyContext for MyContext {} - ") - } -} - -snapshot_check_components! { - check_components! { - #[check_trait(CanUseFooGetter)] - MyContext { - FooGetterComponent>: Index, - } - } - - expand_check_my_context_2(output) { - insta::assert_snapshot!(output, @" - trait CanUseFooGetter< - __Component__, - __Params__: ?Sized, - >: CanUseComponent<__Component__, __Params__> {} - impl CanUseFooGetter>, Index> - for MyContext {} - ") - } -} diff --git a/crates/tests/cgp-tests/tests/preset_tests/generics/mod.rs b/crates/tests/cgp-tests/tests/preset_tests/generics/mod.rs deleted file mode 100644 index 9f6ff9b2..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/generics/mod.rs +++ /dev/null @@ -1,4 +0,0 @@ -pub mod components; -pub mod consumer_delegate; -pub mod contexts; -pub mod preset; diff --git a/crates/tests/cgp-tests/tests/preset_tests/generics/preset.rs b/crates/tests/cgp-tests/tests/preset_tests/generics/preset.rs deleted file mode 100644 index c0b9cbff..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/generics/preset.rs +++ /dev/null @@ -1,22 +0,0 @@ -#[cgp::re_export_imports] -mod preset { - use cgp::prelude::*; - - use crate::preset_tests::generics::components::{ - BarGetterComponent, BarTypeProviderComponent, FooGetterComponent, FooTypeProviderComponent, - }; - - cgp_preset! { - MyGenericPreset { - [ - FooTypeProviderComponent, - BarTypeProviderComponent, - ]: - UseType, - FooGetterComponent>: - UseField, - BarGetterComponent: - UseField, - } - } -} diff --git a/crates/tests/cgp-tests/tests/preset_tests/generics_inheritance/components.rs b/crates/tests/cgp-tests/tests/preset_tests/generics_inheritance/components.rs deleted file mode 100644 index c76a716d..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/generics_inheritance/components.rs +++ /dev/null @@ -1,548 +0,0 @@ -use core::marker::PhantomData; - -use cgp::prelude::*; -use cgp_macro_test_util::{snapshot_cgp_getter, snapshot_cgp_type}; - -snapshot_cgp_type! { - #[cgp_type] - pub trait HasFooType { - type Foo; - } - - expand_has_foo_type(output) { - insta::assert_snapshot!(output, @" - pub trait HasFooType { - type Foo; - } - impl<__Context__> HasFooType for __Context__ - where - __Context__: FooTypeProvider<__Context__>, - { - type Foo = <__Context__ as FooTypeProvider<__Context__>>::Foo; - } - pub trait FooTypeProvider< - __Context__, - >: IsProviderFor { - type Foo; - } - impl<__Provider__, __Context__> FooTypeProvider<__Context__> for __Provider__ - where - __Provider__: DelegateComponent - + IsProviderFor, - <__Provider__ as DelegateComponent< - FooTypeProviderComponent, - >>::Delegate: FooTypeProvider<__Context__>, - { - type Foo = <<__Provider__ as DelegateComponent< - FooTypeProviderComponent, - >>::Delegate as FooTypeProvider<__Context__>>::Foo; - } - pub struct FooTypeProviderComponent; - impl<__Context__> FooTypeProvider<__Context__> for UseContext - where - __Context__: HasFooType, - { - type Foo = <__Context__ as HasFooType>::Foo; - } - impl<__Context__> IsProviderFor for UseContext - where - __Context__: HasFooType, - {} - impl<__Context__, __Components__, __Path__> FooTypeProvider<__Context__> - for RedirectLookup<__Components__, __Path__> - where - __Components__: DelegateComponent<__Path__>, - <__Components__ as DelegateComponent< - __Path__, - >>::Delegate: FooTypeProvider<__Context__>, - { - type Foo = <<__Components__ as DelegateComponent< - __Path__, - >>::Delegate as FooTypeProvider<__Context__>>::Foo; - } - impl< - __Context__, - __Components__, - __Path__, - > IsProviderFor - for RedirectLookup<__Components__, __Path__> - where - __Components__: DelegateComponent<__Path__>, - <__Components__ as DelegateComponent< - __Path__, - >>::Delegate: IsProviderFor - + FooTypeProvider<__Context__>, - {} - impl FooTypeProvider<__Context__> for UseType - where - Foo:, - { - type Foo = Foo; - } - impl IsProviderFor - for UseType - where - Foo:, - {} - impl<__Provider__, Foo, __Context__> FooTypeProvider<__Context__> - for WithProvider<__Provider__> - where - __Provider__: TypeProvider<__Context__, FooTypeProviderComponent, Type = Foo>, - Foo:, - { - type Foo = Foo; - } - impl< - __Provider__, - Foo, - __Context__, - > IsProviderFor for WithProvider<__Provider__> - where - __Provider__: TypeProvider<__Context__, FooTypeProviderComponent, Type = Foo>, - Foo:, - {} - ") - } -} - -snapshot_cgp_type! { - #[cgp_type] - pub trait HasBarType { - type Bar; - } - - expand_has_bar_type(output) { - insta::assert_snapshot!(output, @" - pub trait HasBarType { - type Bar; - } - impl<__Context__> HasBarType for __Context__ - where - __Context__: BarTypeProvider<__Context__>, - { - type Bar = <__Context__ as BarTypeProvider<__Context__>>::Bar; - } - pub trait BarTypeProvider< - __Context__, - >: IsProviderFor { - type Bar; - } - impl<__Provider__, __Context__> BarTypeProvider<__Context__> for __Provider__ - where - __Provider__: DelegateComponent - + IsProviderFor, - <__Provider__ as DelegateComponent< - BarTypeProviderComponent, - >>::Delegate: BarTypeProvider<__Context__>, - { - type Bar = <<__Provider__ as DelegateComponent< - BarTypeProviderComponent, - >>::Delegate as BarTypeProvider<__Context__>>::Bar; - } - pub struct BarTypeProviderComponent; - impl<__Context__> BarTypeProvider<__Context__> for UseContext - where - __Context__: HasBarType, - { - type Bar = <__Context__ as HasBarType>::Bar; - } - impl<__Context__> IsProviderFor for UseContext - where - __Context__: HasBarType, - {} - impl<__Context__, __Components__, __Path__> BarTypeProvider<__Context__> - for RedirectLookup<__Components__, __Path__> - where - __Components__: DelegateComponent<__Path__>, - <__Components__ as DelegateComponent< - __Path__, - >>::Delegate: BarTypeProvider<__Context__>, - { - type Bar = <<__Components__ as DelegateComponent< - __Path__, - >>::Delegate as BarTypeProvider<__Context__>>::Bar; - } - impl< - __Context__, - __Components__, - __Path__, - > IsProviderFor - for RedirectLookup<__Components__, __Path__> - where - __Components__: DelegateComponent<__Path__>, - <__Components__ as DelegateComponent< - __Path__, - >>::Delegate: IsProviderFor - + BarTypeProvider<__Context__>, - {} - impl BarTypeProvider<__Context__> for UseType - where - Bar:, - { - type Bar = Bar; - } - impl IsProviderFor - for UseType - where - Bar:, - {} - impl<__Provider__, Bar, __Context__> BarTypeProvider<__Context__> - for WithProvider<__Provider__> - where - __Provider__: TypeProvider<__Context__, BarTypeProviderComponent, Type = Bar>, - Bar:, - { - type Bar = Bar; - } - impl< - __Provider__, - Bar, - __Context__, - > IsProviderFor for WithProvider<__Provider__> - where - __Provider__: TypeProvider<__Context__, BarTypeProviderComponent, Type = Bar>, - Bar:, - {} - ") - } -} - -snapshot_cgp_getter! { - #[cgp_getter { - name: FooGetterComponent, - provider: FooGetter, - }] - pub trait HasFooAt: HasFooType { - fn foo(&self, _tag: PhantomData) -> &Self::Foo; - } - - expand_has_foo_at(output) { - insta::assert_snapshot!(output, @" - pub trait HasFooAt: HasFooType { - fn foo(&self, _tag: PhantomData) -> &Self::Foo; - } - impl<__Context__, I> HasFooAt for __Context__ - where - __Context__: HasFooType, - __Context__: FooGetter<__Context__, I>, - { - fn foo(&self, _tag: PhantomData) -> &Self::Foo { - __Context__::foo(self, _tag) - } - } - pub trait FooGetter< - __Context__, - I, - >: IsProviderFor, __Context__, (I)> - where - __Context__: HasFooType, - { - fn foo(__context__: &__Context__, _tag: PhantomData) -> &__Context__::Foo; - } - impl<__Provider__, __Context__, I> FooGetter<__Context__, I> for __Provider__ - where - __Context__: HasFooType, - __Provider__: DelegateComponent> - + IsProviderFor, __Context__, (I)>, - <__Provider__ as DelegateComponent< - FooGetterComponent, - >>::Delegate: FooGetter<__Context__, I>, - { - fn foo(__context__: &__Context__, _tag: PhantomData) -> &__Context__::Foo { - <__Provider__ as DelegateComponent< - FooGetterComponent, - >>::Delegate::foo(__context__, _tag) - } - } - pub struct FooGetterComponent(pub ::core::marker::PhantomData<(I)>); - impl<__Context__, I> FooGetter<__Context__, I> for UseContext - where - __Context__: HasFooType, - __Context__: HasFooAt, - { - fn foo(__context__: &__Context__, _tag: PhantomData) -> &__Context__::Foo { - __Context__::foo(__context__, _tag) - } - } - impl<__Context__, I> IsProviderFor, __Context__, (I)> - for UseContext - where - __Context__: HasFooType, - __Context__: HasFooAt, - {} - impl<__Context__, I, __Components__, __Path__> FooGetter<__Context__, I> - for RedirectLookup<__Components__, __Path__> - where - __Context__: HasFooType, - __Path__: ConcatPath>, - __Components__: DelegateComponent< - <__Path__ as ConcatPath>>::Output, - >, - <__Components__ as DelegateComponent< - <__Path__ as ConcatPath>>::Output, - >>::Delegate: FooGetter<__Context__, I>, - { - fn foo(__context__: &__Context__, _tag: PhantomData) -> &__Context__::Foo { - <__Components__ as DelegateComponent< - <__Path__ as ConcatPath>>::Output, - >>::Delegate::foo(__context__, _tag) - } - } - impl< - __Context__, - I, - __Components__, - __Path__, - > IsProviderFor, __Context__, (I)> - for RedirectLookup<__Components__, __Path__> - where - __Context__: HasFooType, - __Path__: ConcatPath>, - __Components__: DelegateComponent< - <__Path__ as ConcatPath>>::Output, - >, - <__Components__ as DelegateComponent< - <__Path__ as ConcatPath>>::Output, - >>::Delegate: IsProviderFor, __Context__, (I)> - + FooGetter<__Context__, I>, - {} - impl<__Context__, I> FooGetter<__Context__, I> for UseFields - where - __Context__: HasFooType, - __Context__: HasField< - Symbol<3, Chars<'f', Chars<'o', Chars<'o', Nil>>>>, - Value = __Context__::Foo, - >, - { - fn foo(__context__: &__Context__, _phantom: PhantomData) -> &__Context__::Foo { - __context__ - .get_field( - ::core::marker::PhantomData::< - Symbol<3, Chars<'f', Chars<'o', Chars<'o', Nil>>>>, - >, - ) - } - } - impl<__Context__, I> IsProviderFor, __Context__, (I)> for UseFields - where - __Context__: HasFooType, - __Context__: HasField< - Symbol<3, Chars<'f', Chars<'o', Chars<'o', Nil>>>>, - Value = __Context__::Foo, - >, - {} - impl<__Context__, I, __Tag__> FooGetter<__Context__, I> for UseField<__Tag__> - where - __Context__: HasFooType, - __Context__: HasField<__Tag__, Value = __Context__::Foo>, - { - fn foo(__context__: &__Context__, _phantom: PhantomData) -> &__Context__::Foo { - __context__.get_field(::core::marker::PhantomData::<__Tag__>) - } - } - impl<__Context__, I, __Tag__> IsProviderFor, __Context__, (I)> - for UseField<__Tag__> - where - __Context__: HasFooType, - __Context__: HasField<__Tag__, Value = __Context__::Foo>, - {} - impl<__Context__, I, __Provider__> FooGetter<__Context__, I> - for WithProvider<__Provider__> - where - __Context__: HasFooType, - __Provider__: FieldGetter< - __Context__, - FooGetterComponent, - Value = __Context__::Foo, - >, - { - fn foo(__context__: &__Context__, _phantom: PhantomData) -> &__Context__::Foo { - __Provider__::get_field( - __context__, - ::core::marker::PhantomData::>, - ) - } - } - impl<__Context__, I, __Provider__> IsProviderFor, __Context__, (I)> - for WithProvider<__Provider__> - where - __Context__: HasFooType, - __Provider__: FieldGetter< - __Context__, - FooGetterComponent, - Value = __Context__::Foo, - >, - {} - ") - } -} - -snapshot_cgp_getter! { - #[cgp_getter { - name: BarGetterComponent, - provider: BarGetter, - }] - pub trait HasBarAt: HasBarType { - fn bar(&self) -> &Self::Bar; - } - - expand_has_bar_at(output) { - insta::assert_snapshot!(output, @" - pub trait HasBarAt: HasBarType { - fn bar(&self) -> &Self::Bar; - } - impl<__Context__, I> HasBarAt for __Context__ - where - __Context__: HasBarType, - __Context__: BarGetter<__Context__, I>, - { - fn bar(&self) -> &Self::Bar { - __Context__::bar(self) - } - } - pub trait BarGetter< - __Context__, - I, - >: IsProviderFor, __Context__, (I)> - where - __Context__: HasBarType, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar; - } - impl<__Provider__, __Context__, I> BarGetter<__Context__, I> for __Provider__ - where - __Context__: HasBarType, - __Provider__: DelegateComponent> - + IsProviderFor, __Context__, (I)>, - <__Provider__ as DelegateComponent< - BarGetterComponent, - >>::Delegate: BarGetter<__Context__, I>, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar { - <__Provider__ as DelegateComponent< - BarGetterComponent, - >>::Delegate::bar(__context__) - } - } - pub struct BarGetterComponent(pub ::core::marker::PhantomData<(I)>); - impl<__Context__, I> BarGetter<__Context__, I> for UseContext - where - __Context__: HasBarType, - __Context__: HasBarAt, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar { - __Context__::bar(__context__) - } - } - impl<__Context__, I> IsProviderFor, __Context__, (I)> - for UseContext - where - __Context__: HasBarType, - __Context__: HasBarAt, - {} - impl<__Context__, I, __Components__, __Path__> BarGetter<__Context__, I> - for RedirectLookup<__Components__, __Path__> - where - __Context__: HasBarType, - __Path__: ConcatPath>, - __Components__: DelegateComponent< - <__Path__ as ConcatPath>>::Output, - >, - <__Components__ as DelegateComponent< - <__Path__ as ConcatPath>>::Output, - >>::Delegate: BarGetter<__Context__, I>, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar { - <__Components__ as DelegateComponent< - <__Path__ as ConcatPath>>::Output, - >>::Delegate::bar(__context__) - } - } - impl< - __Context__, - I, - __Components__, - __Path__, - > IsProviderFor, __Context__, (I)> - for RedirectLookup<__Components__, __Path__> - where - __Context__: HasBarType, - __Path__: ConcatPath>, - __Components__: DelegateComponent< - <__Path__ as ConcatPath>>::Output, - >, - <__Components__ as DelegateComponent< - <__Path__ as ConcatPath>>::Output, - >>::Delegate: IsProviderFor, __Context__, (I)> - + BarGetter<__Context__, I>, - {} - impl<__Context__, I> BarGetter<__Context__, I> for UseFields - where - __Context__: HasBarType, - __Context__: HasField< - Symbol<3, Chars<'b', Chars<'a', Chars<'r', Nil>>>>, - Value = __Context__::Bar, - >, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar { - __context__ - .get_field( - ::core::marker::PhantomData::< - Symbol<3, Chars<'b', Chars<'a', Chars<'r', Nil>>>>, - >, - ) - } - } - impl<__Context__, I> IsProviderFor, __Context__, (I)> for UseFields - where - __Context__: HasBarType, - __Context__: HasField< - Symbol<3, Chars<'b', Chars<'a', Chars<'r', Nil>>>>, - Value = __Context__::Bar, - >, - {} - impl<__Context__, I, __Tag__> BarGetter<__Context__, I> for UseField<__Tag__> - where - __Context__: HasBarType, - __Context__: HasField<__Tag__, Value = __Context__::Bar>, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar { - __context__.get_field(::core::marker::PhantomData::<__Tag__>) - } - } - impl<__Context__, I, __Tag__> IsProviderFor, __Context__, (I)> - for UseField<__Tag__> - where - __Context__: HasBarType, - __Context__: HasField<__Tag__, Value = __Context__::Bar>, - {} - impl<__Context__, I, __Provider__> BarGetter<__Context__, I> - for WithProvider<__Provider__> - where - __Context__: HasBarType, - __Provider__: FieldGetter< - __Context__, - BarGetterComponent, - Value = __Context__::Bar, - >, - { - fn bar(__context__: &__Context__) -> &__Context__::Bar { - __Provider__::get_field( - __context__, - ::core::marker::PhantomData::>, - ) - } - } - impl<__Context__, I, __Provider__> IsProviderFor, __Context__, (I)> - for WithProvider<__Provider__> - where - __Context__: HasBarType, - __Provider__: FieldGetter< - __Context__, - BarGetterComponent, - Value = __Context__::Bar, - >, - {} - ") - } -} diff --git a/crates/tests/cgp-tests/tests/preset_tests/generics_inheritance/contexts.rs b/crates/tests/cgp-tests/tests/preset_tests/generics_inheritance/contexts.rs deleted file mode 100644 index ef2052bc..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/generics_inheritance/contexts.rs +++ /dev/null @@ -1,57 +0,0 @@ -use cgp::prelude::*; -use cgp_macro_test_util::snapshot_check_components; - -use crate::preset_tests::generics_inheritance::components::{ - BarGetterComponent, BarTypeProviderComponent, FooGetterComponent, FooTypeProviderComponent, -}; -use crate::preset_tests::generics_inheritance::preset_b::MyGenericPresetB; - -#[cgp_inherit(MyGenericPresetB<()>)] -#[derive(HasField)] -pub struct MyContext { - pub food: (), - pub bar: (), -} - -snapshot_check_components! { - check_components! { - MyContext { - FooTypeProviderComponent, - BarTypeProviderComponent, - } - } - - expand_check_my_context(output) { - insta::assert_snapshot!(output, @" - trait __CheckMyContext< - __Component__, - __Params__: ?Sized, - >: CanUseComponent<__Component__, __Params__> {} - impl __CheckMyContext for MyContext {} - impl __CheckMyContext for MyContext {} - ") - } -} - -snapshot_check_components! { - check_components! { - #[check_trait(CanUseFooGetter)] - MyContext { - [ - FooGetterComponent, - BarGetterComponent, - ]: I, - } - } - - expand_check_my_context_2(output) { - insta::assert_snapshot!(output, @" - trait CanUseFooGetter< - __Component__, - __Params__: ?Sized, - >: CanUseComponent<__Component__, __Params__> {} - impl CanUseFooGetter, I> for MyContext {} - impl CanUseFooGetter, I> for MyContext {} - ") - } -} diff --git a/crates/tests/cgp-tests/tests/preset_tests/generics_inheritance/mod.rs b/crates/tests/cgp-tests/tests/preset_tests/generics_inheritance/mod.rs deleted file mode 100644 index 663b3bc3..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/generics_inheritance/mod.rs +++ /dev/null @@ -1,4 +0,0 @@ -pub mod components; -pub mod contexts; -pub mod preset_a; -pub mod preset_b; diff --git a/crates/tests/cgp-tests/tests/preset_tests/generics_inheritance/preset_a.rs b/crates/tests/cgp-tests/tests/preset_tests/generics_inheritance/preset_a.rs deleted file mode 100644 index 2c9d8b53..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/generics_inheritance/preset_a.rs +++ /dev/null @@ -1,22 +0,0 @@ -#[cgp::re_export_imports] -mod preset { - use cgp::prelude::*; - - use crate::preset_tests::generics_inheritance::components::{ - BarGetterComponent, BarTypeProviderComponent, FooGetterComponent, FooTypeProviderComponent, - }; - - cgp_preset! { - MyGenericPresetA { - [ - FooTypeProviderComponent, - BarTypeProviderComponent, - ]: - UseType, - FooGetterComponent>: - UseField, - BarGetterComponent: - UseField, - } - } -} diff --git a/crates/tests/cgp-tests/tests/preset_tests/generics_inheritance/preset_b.rs b/crates/tests/cgp-tests/tests/preset_tests/generics_inheritance/preset_b.rs deleted file mode 100644 index 392707f6..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/generics_inheritance/preset_b.rs +++ /dev/null @@ -1,15 +0,0 @@ -#[cgp::re_export_imports] -mod preset { - #![allow(unused_imports)] - - use cgp::prelude::*; - - use crate::preset_tests::generics_inheritance::preset_a::MyGenericPresetA; - - cgp_preset! { - MyGenericPresetB: MyGenericPresetA { - override FooGetterComponent: - UseField, - } - } -} diff --git a/crates/tests/cgp-tests/tests/preset_tests/inheritance/contexts.rs b/crates/tests/cgp-tests/tests/preset_tests/inheritance/contexts.rs deleted file mode 100644 index 86b4b6f7..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/inheritance/contexts.rs +++ /dev/null @@ -1,40 +0,0 @@ -use cgp::prelude::*; -use cgp_macro_test_util::snapshot_check_components; - -use crate::preset_tests::basic::components::{ - BarGetterComponent, BarTypeProviderComponent, FooGetterComponent, FooTypeProviderComponent, -}; -use crate::preset_tests::inheritance::preset_b::{CheckDelegatesForMyPresetB, MyPresetB}; - -#[cgp_inherit(MyPresetB)] -#[derive(HasField)] -pub struct MyContext { - pub foo: (), - pub bar: (), -} - -snapshot_check_components! { - check_components! { - MyContext { - FooTypeProviderComponent, - BarTypeProviderComponent, - FooGetterComponent, - BarGetterComponent, - } - } - - expand_check_my_context(output) { - insta::assert_snapshot!(output, @" - trait __CheckMyContext< - __Component__, - __Params__: ?Sized, - >: CanUseComponent<__Component__, __Params__> {} - impl __CheckMyContext for MyContext {} - impl __CheckMyContext for MyContext {} - impl __CheckMyContext for MyContext {} - impl __CheckMyContext for MyContext {} - ") - } -} - -impl CheckDelegatesForMyPresetB for MyContext {} diff --git a/crates/tests/cgp-tests/tests/preset_tests/inheritance/mod.rs b/crates/tests/cgp-tests/tests/preset_tests/inheritance/mod.rs deleted file mode 100644 index aa310b44..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/inheritance/mod.rs +++ /dev/null @@ -1,3 +0,0 @@ -pub mod contexts; -pub mod preset_a; -pub mod preset_b; diff --git a/crates/tests/cgp-tests/tests/preset_tests/inheritance/preset_a.rs b/crates/tests/cgp-tests/tests/preset_tests/inheritance/preset_a.rs deleted file mode 100644 index 86795e21..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/inheritance/preset_a.rs +++ /dev/null @@ -1,26 +0,0 @@ -#[cgp::re_export_imports] -mod preset { - use cgp::prelude::*; - - use crate::preset_tests::basic::components::{ - BarTypeProviderComponent, FooTypeProviderComponent, - }; - - cgp_preset! { - MyPresetA { - [ - FooTypeProviderComponent, - BarTypeProviderComponent, - ]: - UseType<()>, - } - } - - pub trait CheckDelegatesForMyPresetA: - DelegateComponent> - + DelegateComponent> - { - } - - impl CheckDelegatesForMyPresetA for MyPresetA::Provider {} -} diff --git a/crates/tests/cgp-tests/tests/preset_tests/inheritance/preset_b.rs b/crates/tests/cgp-tests/tests/preset_tests/inheritance/preset_b.rs deleted file mode 100644 index 6f68f808..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/inheritance/preset_b.rs +++ /dev/null @@ -1,26 +0,0 @@ -#[cgp::re_export_imports] -mod preset { - use cgp::prelude::*; - - use crate::preset_tests::basic::components::{BarGetterComponent, FooGetterComponent}; - use crate::preset_tests::inheritance::preset_a::MyPresetA; - - cgp_preset! { - MyPresetB: MyPresetA { - FooGetterComponent: - UseField, - BarGetterComponent: - UseField, - } - } - - pub trait CheckDelegatesForMyPresetB: - DelegateComponent> - + DelegateComponent> - + DelegateComponent> - + DelegateComponent> - { - } - - impl CheckDelegatesForMyPresetB for MyPresetB::Provider {} -} diff --git a/crates/tests/cgp-tests/tests/preset_tests/mod.rs b/crates/tests/cgp-tests/tests/preset_tests/mod.rs deleted file mode 100644 index 7af1795b..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/mod.rs +++ /dev/null @@ -1,6 +0,0 @@ -pub mod basic; -pub mod generics; -pub mod generics_inheritance; -pub mod inheritance; -pub mod nested_inheritance; -pub mod wrapped; diff --git a/crates/tests/cgp-tests/tests/preset_tests/nested_inheritance/contexts.rs b/crates/tests/cgp-tests/tests/preset_tests/nested_inheritance/contexts.rs deleted file mode 100644 index da5aaa69..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/nested_inheritance/contexts.rs +++ /dev/null @@ -1,42 +0,0 @@ -use cgp::prelude::*; -use cgp_macro_test_util::snapshot_check_components; - -use crate::preset_tests::basic::components::{ - BarGetterComponent, BarTypeProviderComponent, FooGetterComponent, FooTypeProviderComponent, -}; -use crate::preset_tests::nested_inheritance::preset_d::{ - CheckDelegatesForNestedPresetD, NestedPresetD, -}; - -#[cgp_inherit(NestedPresetD)] -#[derive(HasField)] -pub struct MyContext { - pub fool: (), - pub bar: (), -} - -snapshot_check_components! { - check_components! { - MyContext { - FooTypeProviderComponent, - BarTypeProviderComponent, - FooGetterComponent, - BarGetterComponent, - } - } - - expand_check_my_context(output) { - insta::assert_snapshot!(output, @" - trait __CheckMyContext< - __Component__, - __Params__: ?Sized, - >: CanUseComponent<__Component__, __Params__> {} - impl __CheckMyContext for MyContext {} - impl __CheckMyContext for MyContext {} - impl __CheckMyContext for MyContext {} - impl __CheckMyContext for MyContext {} - ") - } -} - -impl CheckDelegatesForNestedPresetD for MyContext {} diff --git a/crates/tests/cgp-tests/tests/preset_tests/nested_inheritance/mod.rs b/crates/tests/cgp-tests/tests/preset_tests/nested_inheritance/mod.rs deleted file mode 100644 index 93bd3938..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/nested_inheritance/mod.rs +++ /dev/null @@ -1,5 +0,0 @@ -pub mod contexts; -pub mod preset_a; -pub mod preset_b; -pub mod preset_c; -pub mod preset_d; diff --git a/crates/tests/cgp-tests/tests/preset_tests/nested_inheritance/preset_a.rs b/crates/tests/cgp-tests/tests/preset_tests/nested_inheritance/preset_a.rs deleted file mode 100644 index 1c094d1f..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/nested_inheritance/preset_a.rs +++ /dev/null @@ -1,21 +0,0 @@ -#[cgp::re_export_imports] -mod preset { - use cgp::prelude::*; - - use crate::preset_tests::basic::components::{FooGetterComponent, FooTypeProviderComponent}; - - cgp_preset! { - NestedPresetA { - FooTypeProviderComponent: UseType<()>, - FooGetterComponent: UseField, - } - } - - pub trait CheckDelegatesForNestedPresetA: - DelegateComponent> - + DelegateComponent> - { - } - - impl CheckDelegatesForNestedPresetA for NestedPresetA::Provider {} -} diff --git a/crates/tests/cgp-tests/tests/preset_tests/nested_inheritance/preset_b.rs b/crates/tests/cgp-tests/tests/preset_tests/nested_inheritance/preset_b.rs deleted file mode 100644 index 8b1cc80d..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/nested_inheritance/preset_b.rs +++ /dev/null @@ -1,23 +0,0 @@ -#[cgp::re_export_imports] -mod preset { - use cgp::prelude::*; - - use crate::preset_tests::basic::components::{BarTypeProviderComponent, FooGetterComponent}; - use crate::preset_tests::nested_inheritance::preset_a::NestedPresetA; - - cgp_preset! { - NestedPresetB: NestedPresetA { - override FooGetterComponent: - UseField, - BarTypeProviderComponent: UseType<()>, - } - } - - pub trait CheckDelegatesForNestedPresetB: - DelegateComponent> - + DelegateComponent> - { - } - - impl CheckDelegatesForNestedPresetB for NestedPresetB::Provider {} -} diff --git a/crates/tests/cgp-tests/tests/preset_tests/nested_inheritance/preset_c.rs b/crates/tests/cgp-tests/tests/preset_tests/nested_inheritance/preset_c.rs deleted file mode 100644 index 1e686347..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/nested_inheritance/preset_c.rs +++ /dev/null @@ -1,21 +0,0 @@ -#[cgp::re_export_imports] -mod preset { - use cgp::prelude::*; - - use crate::preset_tests::basic::components::{BarGetterComponent, BarTypeProviderComponent}; - - cgp_preset! { - NestedPresetC { - BarTypeProviderComponent: UseType<()>, - BarGetterComponent: UseField, - } - } - - pub trait CheckDelegatesForNestedPresetC: - DelegateComponent> - + DelegateComponent> - { - } - - impl CheckDelegatesForNestedPresetC for NestedPresetC::Provider {} -} diff --git a/crates/tests/cgp-tests/tests/preset_tests/nested_inheritance/preset_d.rs b/crates/tests/cgp-tests/tests/preset_tests/nested_inheritance/preset_d.rs deleted file mode 100644 index 817244a2..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/nested_inheritance/preset_d.rs +++ /dev/null @@ -1,26 +0,0 @@ -#[cgp::re_export_imports] -mod preset { - use cgp::prelude::*; - - use crate::preset_tests::nested_inheritance::preset_b::NestedPresetB; - use crate::preset_tests::nested_inheritance::preset_c::NestedPresetC; - - cgp_preset! { - NestedPresetD: NestedPresetB + NestedPresetC { - override FooGetterComponent: - UseField, - override BarTypeProviderComponent -> - NestedPresetC::Provider, - } - } - - pub trait CheckDelegatesForNestedPresetD: - DelegateComponent> - + DelegateComponent> - + DelegateComponent> - + DelegateComponent> - { - } - - impl CheckDelegatesForNestedPresetD for NestedPresetD::Provider {} -} diff --git a/crates/tests/cgp-tests/tests/preset_tests/wrapped/context.rs b/crates/tests/cgp-tests/tests/preset_tests/wrapped/context.rs deleted file mode 100644 index 5a1ab8a3..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/wrapped/context.rs +++ /dev/null @@ -1,75 +0,0 @@ -use core::convert::Infallible; - -use cgp::core::error::{ErrorRaiserComponent, ErrorTypeProviderComponent}; -use cgp::prelude::*; -use cgp_macro_test_util::{snapshot_check_components, snapshot_delegate_components}; - -use crate::preset_tests::wrapped::preset::{BoxError, ErrorHandlerPreset}; - -pub struct MyContext; - -snapshot_delegate_components! { - delegate_components! { - MyContext { - ErrorTypeProviderComponent: - UseType, - ErrorRaiserComponent: - ErrorHandlerPreset::Provider, - } - } - - expand_my_context(output) { - insta::assert_snapshot!(output, @" - impl DelegateComponent for MyContext { - type Delegate = UseType; - } - impl< - __Context__, - __Params__, - > IsProviderFor for MyContext - where - UseType< - BoxError, - >: IsProviderFor, - {} - impl DelegateComponent for MyContext { - type Delegate = ErrorHandlerPreset::Provider; - } - impl< - __Context__, - __Params__, - > IsProviderFor for MyContext - where - ErrorHandlerPreset::Provider: IsProviderFor< - ErrorRaiserComponent, - __Context__, - __Params__, - >, - {} - ") - } -} - -snapshot_check_components! { - check_components! { - MyContext { - ErrorRaiserComponent: [ - BoxError, - Infallible, - std::io::Error, - ] - } - } - - expand_check_my_context(output) { - insta::assert_snapshot!(output, @" - trait __CheckMyContext< - __Component__, - __Params__: ?Sized, - >: CanUseComponent<__Component__, __Params__> {} - impl __CheckMyContext for MyContext {} - impl __CheckMyContext for MyContext {} - impl __CheckMyContext for MyContext {} - ") - } -} diff --git a/crates/tests/cgp-tests/tests/preset_tests/wrapped/mod.rs b/crates/tests/cgp-tests/tests/preset_tests/wrapped/mod.rs deleted file mode 100644 index c3f3926b..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/wrapped/mod.rs +++ /dev/null @@ -1,2 +0,0 @@ -pub mod context; -pub mod preset; diff --git a/crates/tests/cgp-tests/tests/preset_tests/wrapped/preset.rs b/crates/tests/cgp-tests/tests/preset_tests/wrapped/preset.rs deleted file mode 100644 index 85203733..00000000 --- a/crates/tests/cgp-tests/tests/preset_tests/wrapped/preset.rs +++ /dev/null @@ -1,21 +0,0 @@ -#[cgp::re_export_imports] -mod preset { - use core::convert::Infallible; - use core::error::Error; - use std::io::Error as IoError; - - use cgp::core::component::UseDelegate; - use cgp::extra::error::{RaiseFrom, RaiseInfallible, ReturnError}; - use cgp::prelude::*; - - pub type BoxError = Box; - - cgp_preset! { - #[wrap_provider(UseDelegate)] - ErrorHandlerPreset { - BoxError: ReturnError, - Infallible: RaiseInfallible, - IoError: RaiseFrom, - } - } -}