working + clean up

Author: sam0x17

frame/examples/basic/src/tests.rs

@@ -19,19 +19,15 @@
 
 use crate::*;
 use frame_support::{
-	assert_ok, derive_impl_inner,
+	assert_ok,
 	dispatch::{DispatchInfo, GetDispatchInfo},
 	macro_magic::use_attr,
 	traits::{ConstU64, OnInitialize},
 };
-use sp_core::H256;
+
 // The testing primitives are very useful for avoiding having to work with signatures
 // or public keys. `u64` is used as the `AccountId` and no `Signature`s are required.
-use sp_runtime::{
-	testing::Header,
-	traits::{BlakeTwo256, IdentityLookup},
-	BuildStorage,
-};
+use sp_runtime::{testing::Header, BuildStorage};
 // Reexport crate as its pallet name for construct_runtime.
 use crate as pallet_example_basic;
 

frame/support/procedural/src/derive_impl.rs

@@ -21,124 +21,7 @@ use macro_magic::core::pretty_print;
 use proc_macro2::TokenStream as TokenStream2;
 use quote::{quote, ToTokens};
 use std::collections::HashSet;
-use syn::{
-	braced, bracketed,
-	parse::{Parse, ParseStream},
-	parse2, parse_quote,
-	punctuated::Punctuated,
-	token::{Brace, Bracket},
-	Ident, ImplItem, ItemImpl, Path, Result, Token, TypePath,
-};
-
-mod keywords {
-	use syn::custom_keyword;
-
-	custom_keyword!(derive_impl);
-	custom_keyword!(partial_impl_block);
-	custom_keyword!(implementing_type);
-	custom_keyword!(type_items);
-	custom_keyword!(fn_items);
-	custom_keyword!(const_items);
-}
-
-pub struct DeriveImplDef {
-	/// The partial impl block that the user provides. This should be interpreted as "override".
-	partial_impl_block: ItemImpl,
-	/// The full path to the type that can be used to receive defaults form.
-	implementing_type: TypePath,
-	/// All of the associated type items that we must eventually implement.
-	type_items: Punctuated<Ident, Token![,]>,
-	/// All of the function items that we must eventually implement.
-	fn_items: Punctuated<Ident, Token![,]>,
-	/// All of the constant items that we must eventually implement.
-	const_items: Punctuated<Ident, Token![,]>,
-}
-
-impl Parse for DeriveImplDef {
-	fn parse(input: ParseStream) -> Result<Self> {
-		// NOTE: unfortunately, the order the keywords here must match what the pallet macro
-		// expands. We can probably used a shared set of keywords later.
-		let mut partial_impl_block;
-		let _ = input.parse::<keywords::partial_impl_block>()?;
-		let _ = input.parse::<Token![=]>()?;
-		let _replace_with_bracket: Bracket = bracketed!(partial_impl_block in input);
-		let _replace_with_brace: Brace = braced!(partial_impl_block in partial_impl_block);
-		let partial_impl_block = partial_impl_block.parse()?;
-
-		let mut implementing_type;
-		let _ = input.parse::<keywords::implementing_type>()?;
-		let _ = input.parse::<Token![=]>()?;
-		let _replace_with_bracket: Bracket = bracketed!(implementing_type in input);
-		let _replace_with_brace: Brace = braced!(implementing_type in implementing_type);
-		let implementing_type = implementing_type.parse()?;
-
-		let mut type_items;
-		let _ = input.parse::<keywords::type_items>()?;
-		let _ = input.parse::<Token![=]>()?;
-		let _replace_with_bracket: Bracket = bracketed!(type_items in input);
-		let _replace_with_brace: Brace = braced!(type_items in type_items);
-		let type_items = Punctuated::<Ident, Token![,]>::parse_terminated(&type_items)?;
-
-		let mut fn_items;
-		let _ = input.parse::<keywords::fn_items>()?;
-		let _ = input.parse::<Token![=]>()?;
-		let _replace_with_bracket: Bracket = bracketed!(fn_items in input);
-		let _replace_with_brace: Brace = braced!(fn_items in fn_items);
-		let fn_items = Punctuated::<Ident, Token![,]>::parse_terminated(&fn_items)?;
-
-		let mut const_items;
-		let _ = input.parse::<keywords::const_items>()?;
-		let _ = input.parse::<Token![=]>()?;
-		let _replace_with_bracket: Bracket = bracketed!(const_items in input);
-		let _replace_with_brace: Brace = braced!(const_items in const_items);
-		let const_items = Punctuated::<Ident, Token![,]>::parse_terminated(&const_items)?;
-
-		Ok(Self { partial_impl_block, type_items, fn_items, const_items, implementing_type })
-	}
-}
-
-pub(crate) fn derive_impl_inner(input: TokenStream2) -> Result<TokenStream2> {
-	println!("input: {}", input);
-	let DeriveImplDef { partial_impl_block, implementing_type, type_items, .. } = parse2(input)?;
-
-	let type_item_name = |i: &ImplItem| {
-		if let ImplItem::Type(t) = i {
-			t.ident.clone()
-		} else {
-			panic!("only support type items for now")
-		}
-	};
-
-	// might be able to mutate `partial_impl_block` along the way, but easier like this for now.
-	let mut final_impl_block = partial_impl_block.clone();
-	let source_crate_path = implementing_type.path.segments.first().unwrap().ident.clone();
-
-	// TODO: ensure type ident specified in `partial_impl_block` is beyond union(type_items,
-	// const_items, fn_items).
-	assert!(
-		partial_impl_block
-			.items
-			.iter()
-			.all(|i| { type_items.iter().find(|tt| tt == &&type_item_name(i)).is_some() }),
-		"some item in the partial_impl_block is unexpected"
-	);
-
-	// for each item that is in `type_items` but not present in `partial_impl_block`, fill it in.
-	type_items.iter().for_each(|ident| {
-		if partial_impl_block.items.iter().any(|i| &type_item_name(i) == ident) {
-			// this is already present in the partial impl block -- noop
-		} else {
-			// add it
-			let tokens = quote::quote!(type #ident = <#implementing_type as #source_crate_path::pallet::DefaultConfig>::#ident;);
-			let parsed: ImplItem = parse2(tokens).expect("it is a valid type item");
-			debug_assert!(matches!(parsed, ImplItem::Type(_)));
-
-			final_impl_block.items.push(parsed)
-		}
-	});
-
-	Ok(quote::quote!(#final_impl_block))
-}
+use syn::{parse2, parse_quote, Ident, ImplItem, ItemImpl, Path, Result};
 
 fn impl_item_ident(impl_item: &ImplItem) -> Option<Ident> {
 	match impl_item {
@@ -161,6 +44,8 @@ fn combine_impls(local_impl: ItemImpl, foreign_impl: ItemImpl, foreign_path: Pat
 		.filter(|impl_item| impl_item_ident(impl_item).is_none())
 		.cloned()
 		.collect();
+	// // TODO: may not be accurate.
+	// // source_crate_path = frame_system
 	let source_crate_path = foreign_path.segments.first().unwrap().ident.clone();
 	let mut final_impl = local_impl;
 	final_impl.items.extend(
@@ -220,41 +105,4 @@ pub fn derive_impl(
 	pretty_print(&combined_impl.to_token_stream());
 
 	Ok(quote!(#combined_impl))
-	// attr: frame_system::preludes::testing::Impl
-	// tokens:
-	// impl frame_system::Config for Test {
-	//	// These are all defined by system as mandatory.
-	// 	type BaseCallFilter = frame_support::traits::Everything;
-	// 	type RuntimeEvent = RuntimeEvent;
-	// 	type RuntimeCall = RuntimeCall;
-	// 	type RuntimeOrigin = RuntimeOrigin;
-	// 	type OnSetCode = frame_system::DefaultSetCode<Self>;
-	// 	type PalletInfo = PalletInfo;
-	// 	type Header = Header;
-	// 	// We decide to override this one.
-	// 	type AccountData = pallet_balances::AccountData<u64>;
-	// }
-	// let implementing_type: TypePath = parse2(attrs.clone())?;
-	// // ideas for sam:
-	// // let other_path_tokens = magic_macro!(path_to_other_path_token);
-	// // let foreign_trait_tokens = import_tokens_indirect!(frame_system::testing::DefaultConfig);
-	// // println!("{}", foreign_trait_tokens.to_string());
-
-	// let frame_support = generate_crate_access_2018("frame-support")?;
-	// // TODO: may not be accurate.
-	// let source_crate_path = implementing_type.path.segments.first().unwrap().ident.clone();
-	// // source_crate_path = frame_system
-
-	// //let tokens = import_tokens_indirect!(::pallet_example_basic::pallet::Config);
-
-	// Ok(quote::quote!(
-	// 	#frame_support::tt_call! {
-	// 		macro = [{ #source_crate_path::tt_config_items }] // frame_system::tt_config_items
-	// 		frame_support = [{ #frame_support }] // ::frame_support
-	// 		~~> #frame_support::derive_impl_inner! {
-	// 			partial_impl_block = [{ #input }]
-	// 			implementing_type = [{ #attrs }]
-	// 		}
-	// 	}
-	// ))
 }

frame/support/procedural/src/lib.rs

@@ -786,13 +786,6 @@ pub fn derive_impl(attrs: TokenStream, input: TokenStream) -> TokenStream {
 		.into()
 }
 
-#[proc_macro]
-pub fn derive_impl_inner(input: TokenStream) -> TokenStream {
-	derive_impl::derive_impl_inner(input.into())
-		.unwrap_or_else(|r| r.into_compile_error())
-		.into()
-}
-
 /// Used internally to decorate pallet attribute macro stubs when they are erroneously used
 /// outside of a pallet module
 fn pallet_macro_stub() -> TokenStream {

frame/support/src/lib.rs

@@ -212,13 +212,9 @@ impl TypeId for PalletId {
 /// ```
 pub use frame_support_procedural::storage_alias;
 
-/// Test
 #[use_attr]
 pub use frame_support_procedural::derive_impl;
 
-#[doc(hidden)]
-pub use frame_support_procedural::derive_impl_inner;
-
 /// Create new implementations of the [`Get`](crate::traits::Get) trait.
 ///
 /// The so-called parameter type can be created in four different ways:

frame/system/src/lib.rs

@@ -209,10 +209,10 @@ pub mod pallet {
 			use macro_magic::export_tokens;
 			use sp_runtime::traits::IdentityLookup;
 
-			pub struct Impl {}
+			pub struct TestDefaultConfig {}
 
 			#[export_tokens(TestDefaultConfig)]
-			impl DefaultConfig for Impl {
+			impl DefaultConfig for TestDefaultConfig {
 				type Version = ();
 				type BlockWeights = ();
 				type BlockLength = ();