From 9ef619d0dde74b0e9360d1602abde333ec0f1410 Mon Sep 17 00:00:00 2001 From: wandalen Date: Fri, 29 Mar 2024 11:40:49 +0200 Subject: [PATCH] experimenting --- .../tests/inc/former_tests/a_primitives.rs | 3 +- .../inc/former_tests/a_primitives_expanded.rs | 273 +++++++++++++++++- .../inc/former_tests/a_primitives_manual.rs | 1 - module/core/former/tests/inc/mod.rs | 2 +- module/core/former_meta/src/derive/former.rs | 79 +++-- 5 files changed, 324 insertions(+), 34 deletions(-) diff --git a/module/core/former/tests/inc/former_tests/a_primitives.rs b/module/core/former/tests/inc/former_tests/a_primitives.rs index c39429b63a..676ee5752c 100644 --- a/module/core/former/tests/inc/former_tests/a_primitives.rs +++ b/module/core/former/tests/inc/former_tests/a_primitives.rs @@ -12,4 +12,5 @@ pub struct Struct1 // -include!( "./only_test/primitives.rs" ); +// xxx : uncomment +// include!( "./only_test/primitives.rs" ); diff --git a/module/core/former/tests/inc/former_tests/a_primitives_expanded.rs b/module/core/former/tests/inc/former_tests/a_primitives_expanded.rs index 812d40be6e..ea4eee4e00 100644 --- a/module/core/former/tests/inc/former_tests/a_primitives_expanded.rs +++ b/module/core/former/tests/inc/former_tests/a_primitives_expanded.rs @@ -11,7 +11,278 @@ pub struct Struct1 string_optional_1 : Option< String >, } -// = formed +// = generated + +// #[ automatically_derived ] +// impl Struct1 +// { +// #[ doc = r"" ] +// #[ doc = r" Make former, variation of builder pattern to form structure defining values of fields step by step." ] +// #[ doc = r"" ] +// #[ inline( always ) ] +// // pub fn former() -> Struct1Former< (), former::ReturnPreformed > +// pub fn former() -> Struct1Former<> +// { +// Struct1Former::new() +// } +// } +// +// #[ derive( Debug, Default ) ] +// pub struct Struct1FormerDefinition; +// +// impl former::FormerDefinitionTypes for Struct1FormerDefinition +// { +// type Storage = Struct1FormerStorage; +// type Formed = Struct1; +// type Context = (); +// } +// +// impl former::FormerDefinition for Struct1FormerDefinition +// { +// type Types = Struct1FormerDefinition; +// type End = former::ReturnPreformed; +// } +// +// #[ doc = "Container of a corresponding former." ] +// pub struct Struct1FormerStorage +// { +// #[ doc = r" A field" ] +// pub int_1 : ::core::option::Option< i32 >, +// #[ doc = r" A field" ] +// pub string_1 : ::core::option::Option< String >, +// #[ doc = r" A field" ] +// pub int_optional_1 : core::option::Option< i32 >, +// #[ doc = r" A field" ] +// pub string_optional_1 : Option< String >, +// } +// +// impl ::core::default::Default for Struct1FormerStorage +// { +// #[ inline( always ) ] +// fn default() -> Self +// { +// Self +// { +// int_1 : ::core::option::Option::None, +// string_1 : ::core::option::Option::None, +// int_optional_1 : ::core::option::Option::None, +// string_optional_1 : ::core::option::Option::None, +// } +// } +// } +// +// impl former::Storage for Struct1FormerStorage +// { +// // type Definition = Struct1FormerDefinition; +// type Formed = Struct1; +// } +// +// impl former::StoragePerform for Struct1FormerStorage +// { +// fn preform( mut self ) -> < Struct1FormerDefinition as former::FormerDefinitionTypes >::Formed +// { +// let int_1 = if self.int_1.is_some() +// { +// self.int_1.take().unwrap() +// } +// else +// { +// { +// trait MaybeDefault< T > +// { +// fn maybe_default( self : &Self ) -> T +// { +// panic!( "Field 'int_1' isn't initialized" ) +// } +// } +// impl< T > MaybeDefault< T > for &::core::marker::PhantomData< T > {} +// impl< T > MaybeDefault< T > for ::core::marker::PhantomData< T > +// where T : ::core::default::Default, +// { +// fn maybe_default( self : &Self ) -> T +// { +// T::default() +// } +// } +// ( &::core::marker::PhantomData::< i32 > ).maybe_default() +// } +// }; +// let string_1 = if self.string_1.is_some() +// { +// self.string_1.take().unwrap() +// } +// else +// { +// { +// trait MaybeDefault< T > +// { +// fn maybe_default( self : &Self ) -> T +// { +// panic!( "Field 'string_1' isn't initialized" ) +// } +// } +// impl< T > MaybeDefault< T > for &::core::marker::PhantomData< T > {} +// impl< T > MaybeDefault< T > for ::core::marker::PhantomData< T > +// where T : ::core::default::Default, +// { +// fn maybe_default( self : &Self ) -> T +// { +// T::default() +// } +// } +// ( &::core::marker::PhantomData::< String > ).maybe_default() +// } +// }; +// let int_optional_1 = if self.int_optional_1.is_some() +// { +// ::core::option::Option::Some( self.int_optional_1.take().unwrap() ) +// } +// else +// { +// ::core::option::Option::None +// }; +// let string_optional_1 = if self.string_optional_1.is_some() +// { +// ::core::option::Option::Some( self.string_optional_1.take().unwrap() ) +// } +// else +// { +// ::core::option::Option::None +// }; +// let result = Struct1 +// { +// int_1, +// string_1, +// int_optional_1, +// string_optional_1, +// }; +// return result; +// } +// } +// +// pub struct Struct1Former +// < +// // FormerContext = Struct1, +// // FormerEnd = former::ReturnPreformed, +// > +// // where +// // FormerEnd : former::FormingEnd< Struct1FormerDefinition >, +// { +// storage : Struct1FormerStorage, +// context : core::option::Option< FormerContext >, +// on_end : core::option::Option< FormerEnd >, +// } +// +// #[ automatically_derived ] +// impl< FormerContext, FormerEnd > Struct1Former< FormerContext, FormerEnd > +// // where +// // FormerEnd : former::FormingEnd< Struct1FormerDefinition >, +// { +// #[ doc = r"" ] +// #[ doc = r" Finish setting options and return formed entity." ] +// #[ doc = r"" ] +// #[ inline( always ) ] +// pub fn preform( self ) -> < Struct1FormerDefinition as former::FormerDefinitionTypes >::Formed +// { +// < Struct1FormerStorage as former::StoragePerform >::preform( self.storage ) +// } +// +// #[ inline( always ) ] +// pub fn perform( self ) -> < Struct1FormerDefinition as former::FormerDefinitionTypes >::Formed +// { +// let result = self.form(); +// return result; +// } +// #[ doc = r"" ] +// #[ doc = r" Begin the process of forming. Expects context of forming to return it after forming." ] +// #[ doc = r"" ] +// #[ inline( always ) ] +// pub fn begin( mut storage : core::option::Option< Struct1FormerStorage >, context : core::option::Option< FormerContext >, on_end : FormerEnd, ) -> Self +// { +// if storage.is_none() +// { +// storage = Some( ::core::default::Default::default() ); +// } +// Self +// { +// storage : storage.unwrap(), +// context : context, +// on_end : ::core::option::Option::Some( on_end ), +// } +// } +// #[ doc = r"" ] +// #[ doc = r" End the process of forming returning original context of forming." ] +// #[ doc = r"" ] +// #[ inline( always ) ] +// pub fn form( self ) -> < Struct1FormerDefinition as former::FormerDefinitionTypes >::Formed +// { +// self.end() +// } +// #[ doc = r"" ] +// #[ doc = r" End the process of forming returning original context of forming." ] +// #[ doc = r"" ] +// #[ inline( always ) ] +// pub fn end( mut self ) -> < Struct1FormerDefinition as former::FormerDefinitionTypes >::Formed +// { +// let on_end = self.on_end.take().unwrap(); +// let context = self.context.take(); +// // on_end.call( self.storage, context ) +// former::FormingEnd::< Struct1FormerDefinition >::call( &on_end, self.storage, context ) +// } +// #[ doc = "Setter for the 'int_1' field." ] +// #[ inline ] +// pub fn int_1< Src >( mut self, src : Src ) -> Self +// where +// Src : ::core::convert::Into< i32 >, +// { +// debug_assert!( self.storage.int_1.is_none() ); +// self.storage.int_1 = ::core::option::Option::Some( src.into() ); +// self +// } +// #[ doc = "Setter for the 'string_1' field." ] +// #[ inline ] +// pub fn string_1< Src >( mut self, src : Src ) -> Self +// where +// Src : ::core::convert::Into< String >, +// { +// debug_assert!( self.storage.string_1.is_none() ); +// self.storage.string_1 = ::core::option::Option::Some( src.into() ); +// self +// } +// #[ doc = "Setter for the 'int_optional_1' field." ] +// #[ inline ] +// pub fn int_optional_1< Src >( mut self, src : Src ) -> Self +// where +// Src : ::core::convert::Into< i32 >, +// { +// debug_assert!( self.storage.int_optional_1.is_none() ); +// self.storage.int_optional_1 = ::core::option::Option::Some( src.into() ); +// self +// } +// #[ doc = "Setter for the 'string_optional_1' field." ] +// #[ inline ] +// pub fn string_optional_1< Src >( mut self, src : Src ) -> Self +// where +// Src : ::core::convert::Into< String >, +// { +// debug_assert!( self.storage.string_optional_1.is_none() ); +// self.storage.string_optional_1 = ::core::option::Option::Some( src.into() ); +// self +// } +// } +// +// #[ automatically_derived ] +// impl Struct1Former< (), former::ReturnPreformed > +// { +// #[ doc = r"" ] +// #[ doc = r" Construct new instance of former with default parameters." ] +// #[ doc = r"" ] +// #[ inline( always ) ] +// pub fn new() -> Self +// { +// Self::begin( None, None, former::ReturnPreformed, ) +// } +// } // diff --git a/module/core/former/tests/inc/former_tests/a_primitives_manual.rs b/module/core/former/tests/inc/former_tests/a_primitives_manual.rs index f05665a731..ee225ae1fc 100644 --- a/module/core/former/tests/inc/former_tests/a_primitives_manual.rs +++ b/module/core/former/tests/inc/former_tests/a_primitives_manual.rs @@ -40,7 +40,6 @@ for Struct1FormerDefinition type Storage = Struct1FormerStorage; type Formed = Struct1; type Context = (); - // type End = former::ReturnPreformed; } impl former::FormerDefinition diff --git a/module/core/former/tests/inc/mod.rs b/module/core/former/tests/inc/mod.rs index c9b4a5805f..68ee5ba65e 100644 --- a/module/core/former/tests/inc/mod.rs +++ b/module/core/former/tests/inc/mod.rs @@ -17,8 +17,8 @@ mod former_tests mod container_former_hashmap; mod a_primitives_manual; + mod a_primitives_expanded; // mod a_primitives; - // mod a_primitives_expanded; // mod a_containers_without_runtime_manual; // mod a_containers_without_runtime; // #[ cfg( not( feature = "no_std" ) ) ] diff --git a/module/core/former_meta/src/derive/former.rs b/module/core/former_meta/src/derive/former.rs index 52d39080e2..6727879445 100644 --- a/module/core/former_meta/src/derive/former.rs +++ b/module/core/former_meta/src/derive/former.rs @@ -743,7 +743,7 @@ For specifying custom default value use attribute `default`. For example: pub fn performer< 'a > ( _name_ident : &syn::Ident, - former_descriptor_name_ident : &syn::Ident, + former_definition_name_ident : &syn::Ident, generics_ty : &syn::TypeGenerics< '_ >, attrs : impl Iterator< Item = &'a syn::Attribute >, ) @@ -755,7 +755,7 @@ pub fn performer< 'a > return result; }; // let mut perform_output = qt!{ #name_ident #generics_ty }; - let mut perform_output = qt!{ < #former_descriptor_name_ident #generics_ty as former::FormerDefinition >::Formed }; + let mut perform_output = qt!{ < #former_definition_name_ident #generics_ty as former::FormerDefinitionTypes >::Formed }; let mut perform_generics = qt!{}; for attr in attrs @@ -827,8 +827,10 @@ pub fn former( input : proc_macro::TokenStream ) -> Result< TokenStream > let former_name_ident = syn::Ident::new( &former_name, name_ident.span() ); let former_storage_name = format!( "{}FormerStorage", name_ident ); let former_storage_name_ident = syn::Ident::new( &former_storage_name, name_ident.span() ); - let former_descriptor_name = format!( "{}FormerDefinition", name_ident ); - let former_descriptor_name_ident = syn::Ident::new( &former_descriptor_name, name_ident.span() ); + let former_definition_name = format!( "{}FormerDefinition", name_ident ); + let former_definition_name_ident = syn::Ident::new( &former_definition_name, name_ident.span() ); + // let former_definition_type_name = format!( "{}FormerDefinitionTypes", name_ident ); + // let former_definition_type_name_ident = syn::Ident::new( &former_definition_name, name_ident.span() ); /* generic parameters */ @@ -848,12 +850,12 @@ pub fn former( input : proc_macro::TokenStream ) -> Result< TokenStream > // add embedded generic parameters let mut extra_generics : syn::Generics = parse_quote! { - < __FormerContext = #name_ident #generics_ty, __FormerEnd = former::ReturnFormed > + < __FormerContext = #name_ident #generics_ty, __FormerEnd = former::ReturnPreformed > }; extra_generics.where_clause = parse_quote! { where - __FormerEnd : former::FormingEnd< #former_descriptor_name_ident #generics_ty, __FormerContext >, + __FormerEnd : former::FormingEnd< #former_definition_name_ident #generics_ty >, }; // xxx : write helper to fix bug with where let generics_of_former = generics::merge( &generics, &extra_generics ); @@ -867,7 +869,7 @@ pub fn former( input : proc_macro::TokenStream ) -> Result< TokenStream > let ( perform, perform_output, perform_generics ) = performer ( &name_ident, - &former_descriptor_name_ident, + &former_definition_name_ident, &generics_ty, ast.attrs.iter(), )?; @@ -932,32 +934,48 @@ pub fn former( input : proc_macro::TokenStream ) -> Result< TokenStream > /// Make former, variation of builder pattern to form structure defining values of fields step by step. /// #[ inline( always ) ] - pub fn former() -> #former_name_ident < #generics_params (), former::ReturnFormed > + // pub fn former() -> #former_name_ident < #generics_params (), former::ReturnPreformed > + pub fn former() -> #former_name_ident < #generics_params > { #former_name_ident :: new() } } - // = descriptor + // = definition - #[ derive( Debug ) ] - pub struct #former_descriptor_name_ident #generics_ty; + #[ derive( Debug, Default ) ] + pub struct #former_definition_name_ident #generics_ty; - impl #generics_impl #former_descriptor_name_ident #generics_ty + impl #generics_impl former::FormerDefinitionTypes + for #former_definition_name_ident #generics_ty { - pub fn new() -> Self - { - Self - } + type Storage = #former_storage_name_ident #generics_ty; + type Formed = #name_ident #generics_ty; + type Context = (); } impl #generics_impl former::FormerDefinition - for #former_descriptor_name_ident #generics_ty + for #former_definition_name_ident #generics_ty { - type Storage = #former_storage_name_ident #generics_ty; - type Formed = #name_ident #generics_ty; + type Types = #former_definition_name_ident #generics_ty; + type End = former::ReturnPreformed; } +// impl former::FormerDefinitionTypes +// for Struct1FormerDefinition +// { +// type Storage = Struct1FormerStorage; +// type Formed = Struct1; +// type Context = (); +// } +// +// impl former::FormerDefinition +// for Struct1FormerDefinition +// { +// type Types = Struct1FormerDefinition; +// type End = former::ReturnPreformed; +// } + // = storage // xxx : rename to storage @@ -991,7 +1009,8 @@ pub fn former( input : proc_macro::TokenStream ) -> Result< TokenStream > #generics_where { // type Definition = Struct1FormerDefinition; - type Definition = #former_descriptor_name_ident #generics_ty; + // type Definition = #former_definition_name_ident #generics_ty; + type Formed = #name_ident #generics_ty; } // generics_impl, generics_ty, generics_where @@ -1001,11 +1020,11 @@ pub fn former( input : proc_macro::TokenStream ) -> Result< TokenStream > { // fn preform( mut self ) -> #former_storage_name_ident #generics_ty - fn preform( mut self ) -> < #former_descriptor_name_ident #generics_ty as former::FormerDefinition >::Formed + fn preform( mut self ) -> < #former_definition_name_ident #generics_ty as former::FormerDefinitionTypes >::Formed { #( #fields_form )* // Rust does not support that, yet - // let result = < #former_descriptor_name_ident #generics_ty as former::FormerDefinition >::Formed + // let result = < #former_definition_name_ident #generics_ty as former::FormerDefinitionTypes >::Formed let result = #name_ident #generics_ty { #( #fields_names, )* @@ -1018,7 +1037,6 @@ pub fn former( input : proc_macro::TokenStream ) -> Result< TokenStream > // = former #[ doc = #doc_former_struct ] - #[ automatically_derived ] pub struct #former_name_ident < #generics_of_former_with_defaults > #generics_of_former_where { @@ -1037,7 +1055,7 @@ pub fn former( input : proc_macro::TokenStream ) -> Result< TokenStream > /// Finish setting options and return formed entity. /// #[ inline( always ) ] - pub fn preform( self ) -> < #former_descriptor_name_ident #generics_ty as former::FormerDefinition >::Formed + pub fn preform( self ) -> < #former_definition_name_ident #generics_ty as former::FormerDefinitionTypes >::Formed // #name_ident #generics_ty { < #former_storage_name_ident #generics_ty as former::StoragePerform >::preform( self.storage ) @@ -1089,7 +1107,7 @@ pub fn former( input : proc_macro::TokenStream ) -> Result< TokenStream > /// End the process of forming returning original context of forming. /// #[ inline( always ) ] - pub fn form( self ) -> < #former_descriptor_name_ident #generics_ty as former::FormerDefinition >::Formed + pub fn form( self ) -> < #former_definition_name_ident #generics_ty as former::FormerDefinitionTypes >::Formed { self.end() } @@ -1098,12 +1116,13 @@ pub fn former( input : proc_macro::TokenStream ) -> Result< TokenStream > /// End the process of forming returning original context of forming. /// #[ inline( always ) ] - pub fn end( mut self ) -> < #former_descriptor_name_ident #generics_ty as former::FormerDefinition >::Formed + pub fn end( mut self ) -> < #former_definition_name_ident #generics_ty as former::FormerDefinitionTypes >::Formed { let on_end = self.on_end.take().unwrap(); let context = self.context.take(); // let storage = self.form(); - on_end.call( self.storage, context ) + // on_end.call( self.storage, context ) + former::FormingEnd::< #former_definition_name_ident #generics_ty >::call( &on_end, self.storage, context ) } #( @@ -1113,7 +1132,7 @@ pub fn former( input : proc_macro::TokenStream ) -> Result< TokenStream > } #[ automatically_derived ] - impl #generics_impl #former_name_ident < #generics_params (), former::ReturnFormed > + impl #generics_impl #former_name_ident < #generics_params (), former::ReturnPreformed > #generics_where { @@ -1123,12 +1142,12 @@ pub fn former( input : proc_macro::TokenStream ) -> Result< TokenStream > #[ inline( always ) ] pub fn new() -> Self { - // #former_name_ident :: < #generics_params #name_ident #generics_ty, former::ReturnFormed > :: begin + // #former_name_ident :: < #generics_params #name_ident #generics_ty, former::ReturnPreformed > :: begin Self :: begin ( None, None, - former::ReturnFormed, + former::ReturnPreformed, ) }