Derive no bound macros (to be also used in pallet macro) (#7280)

* derive no bound macros

* explicit different variant for partialeq

* fix ui for 1.47

* Apply suggestions from code review

Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>

* move test to frame-support-test

* renames, code organization and remove expect as suggested

* better doc

* remove DebugStripped introduce RuntimeDebugNoBound

* rename

* fix test

* fix ui test

* fix line width

* Update frame/support/src/lib.rs

Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>

* Update frame/support/procedural/src/clone_no_bound.rs

Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>

* Apply suggestions from code review

Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>

* fix confusing dead code

Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>

substrate/frame/support/Cargo.toml

@@ -24,7 +24,7 @@ sp-tracing = { version = "2.0.0", default-features = false, path = "../../primit
 sp-core = { version = "2.0.0", default-features = false, path = "../../primitives/core" }
 sp-arithmetic = { version = "2.0.0", default-features = false, path = "../../primitives/arithmetic" }
 sp-inherents = { version = "2.0.0", default-features = false, path = "../../primitives/inherents" }
-frame-support-procedural = { version = "2.0.0", path = "./procedural" }
+frame-support-procedural = { version = "2.0.0", default-features = false, path = "./procedural" }
 paste = "0.1.6"
 once_cell = { version = "1", default-features = false, optional = true }
 sp-state-machine = { version = "0.8.0", optional = true, path = "../../primitives/state-machine" }
@@ -52,6 +52,7 @@ std = [
 	"frame-metadata/std",
 	"sp-inherents/std",
 	"sp-state-machine",
+	"frame-support-procedural/std",
 ]
 nightly = []
 strict = []

substrate/frame/support/procedural/Cargo.toml

@@ -19,3 +19,7 @@ frame-support-procedural-tools = { version = "2.0.0", path = "./tools" }
 proc-macro2 = "1.0.6"
 quote = "1.0.3"
 syn = { version = "1.0.7", features = ["full"] }
+
+[features]
+default = ["std"]
+std = []

substrate/frame/support/procedural/src/clone_no_bound.rs

@@ -0,0 +1,103 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2020 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use syn::spanned::Spanned;
+
+/// Derive Clone but do not bound any generic.
+pub fn derive_clone_no_bound(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	let input: syn::DeriveInput = match syn::parse(input) {
+		Ok(input) => input,
+		Err(e) => return e.to_compile_error().into(),
+	};
+
+	let name = &input.ident;
+	let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+
+	let impl_ = match input.data {
+		syn::Data::Struct(struct_) => match struct_.fields {
+			syn::Fields::Named(named) => {
+				let fields = named.named.iter()
+					.map(|i| &i.ident)
+					.map(|i| quote::quote_spanned!(i.span() =>
+						#i: core::clone::Clone::clone(&self.#i)
+					));
+
+				quote::quote!( Self { #( #fields, )* } )
+			},
+			syn::Fields::Unnamed(unnamed) => {
+				let fields = unnamed.unnamed.iter().enumerate()
+					.map(|(i, _)| syn::Index::from(i))
+					.map(|i| quote::quote_spanned!(i.span() =>
+						core::clone::Clone::clone(&self.#i)
+					));
+
+				quote::quote!( Self ( #( #fields, )* ) )
+			},
+			syn::Fields::Unit => {
+				quote::quote!( Self )
+			}
+		},
+		syn::Data::Enum(enum_) => {
+			let variants = enum_.variants.iter()
+				.map(|variant| {
+					let ident = &variant.ident;
+					match &variant.fields {
+						syn::Fields::Named(named) => {
+							let captured = named.named.iter().map(|i| &i.ident);
+							let cloned = captured.clone()
+								.map(|i| quote::quote_spanned!(i.span() =>
+									#i: core::clone::Clone::clone(#i)
+								));
+							quote::quote!(
+								Self::#ident { #( ref #captured, )* } => Self::#ident { #( #cloned, )*}
+							)
+						},
+						syn::Fields::Unnamed(unnamed) => {
+							let captured = unnamed.unnamed.iter().enumerate()
+								.map(|(i, f)| syn::Ident::new(&format!("_{}", i), f.span()));
+							let cloned = captured.clone()
+								.map(|i| quote::quote_spanned!(i.span() =>
+									core::clone::Clone::clone(#i)
+								));
+							quote::quote!(
+								Self::#ident ( #( ref #captured, )* ) => Self::#ident ( #( #cloned, )*)
+							)
+						},
+						syn::Fields::Unit => quote::quote!( Self::#ident => Self::#ident ),
+					}
+				});
+
+			quote::quote!(match self {
+				#( #variants, )*
+			})
+		},
+		syn::Data::Union(_) => {
+			let msg = "Union type not supported by `derive(CloneNoBound)`";
+			return syn::Error::new(input.span(), msg).to_compile_error().into()
+		},
+	};
+
+	quote::quote!(
+		const _: () = {
+			impl #impl_generics core::clone::Clone for #name #ty_generics #where_clause {
+				fn clone(&self) -> Self {
+					#impl_
+				}
+			}
+		};
+	).into()
+}

substrate/frame/support/procedural/src/debug_no_bound.rs

@@ -0,0 +1,114 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2020 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use syn::spanned::Spanned;
+
+/// Derive Debug but do not bound any generics.
+pub fn derive_debug_no_bound(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	let input: syn::DeriveInput = match syn::parse(input) {
+		Ok(input) => input,
+		Err(e) => return e.to_compile_error().into(),
+	};
+
+	let input_ident = &input.ident;
+	let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+
+	let impl_ = match input.data {
+		syn::Data::Struct(struct_) => match struct_.fields {
+			syn::Fields::Named(named) => {
+				let fields = named.named.iter()
+					.map(|i| &i.ident)
+					.map(|i| quote::quote_spanned!(i.span() => .field(stringify!(#i), &self.#i) ));
+
+				quote::quote!(
+					fmt.debug_struct(stringify!(#input_ident))
+						#( #fields )*
+						.finish()
+				)
+			},
+			syn::Fields::Unnamed(unnamed) => {
+				let fields = unnamed.unnamed.iter().enumerate()
+					.map(|(i, _)| syn::Index::from(i))
+					.map(|i| quote::quote_spanned!(i.span() => .field(&self.#i) ));
+
+				quote::quote!(
+					fmt.debug_tuple(stringify!(#input_ident))
+						#( #fields )*
+						.finish()
+				)
+			},
+			syn::Fields::Unit => quote::quote!( fmt.write_str(stringify!(#input_ident)) ),
+		},
+		syn::Data::Enum(enum_) => {
+			let variants = enum_.variants.iter()
+				.map(|variant| {
+					let ident = &variant.ident;
+					let full_variant_str = format!("{}::{}", input_ident, ident);
+					match &variant.fields {
+						syn::Fields::Named(named) => {
+							let captured = named.named.iter().map(|i| &i.ident);
+							let debugged = captured.clone()
+								.map(|i| quote::quote_spanned!(i.span() =>
+									.field(stringify!(#i), &#i)
+								));
+							quote::quote!(
+								Self::#ident { #( ref #captured, )* } => {
+									fmt.debug_struct(#full_variant_str)
+										#( #debugged )*
+										.finish()
+								}
+							)
+						},
+						syn::Fields::Unnamed(unnamed) => {
+							let captured = unnamed.unnamed.iter().enumerate()
+								.map(|(i, f)| syn::Ident::new(&format!("_{}", i), f.span()));
+							let debugged = captured.clone()
+								.map(|i| quote::quote_spanned!(i.span() => .field(&#i)));
+							quote::quote!(
+								Self::#ident ( #( ref #captured, )* ) => {
+									fmt.debug_tuple(#full_variant_str)
+										#( #debugged )*
+										.finish()
+								}
+							)
+						},
+						syn::Fields::Unit => quote::quote!(
+							Self::#ident => fmt.write_str(#full_variant_str)
+						),
+					}
+				});
+
+			quote::quote!(match *self {
+				#( #variants, )*
+			})
+		},
+		syn::Data::Union(_) => {
+			let msg = "Union type not supported by `derive(DebugNoBound)`";
+			return syn::Error::new(input.span(), msg).to_compile_error().into()
+		},
+	};
+
+	quote::quote!(
+		const _: () = {
+			impl #impl_generics core::fmt::Debug for #input_ident #ty_generics #where_clause {
+				fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
+					#impl_
+				}
+			}
+		};
+	).into()
+}

substrate/frame/support/procedural/src/lib.rs

@@ -22,6 +22,9 @@
 mod storage;
 mod construct_runtime;
 mod transactional;
+mod debug_no_bound;
+mod clone_no_bound;
+mod partial_eq_no_bound;
 
 use proc_macro::TokenStream;
 
@@ -326,6 +329,75 @@ pub fn transactional(attr: TokenStream, input: TokenStream) -> TokenStream {
 	transactional::transactional(attr, input).unwrap_or_else(|e| e.to_compile_error().into())
 }
 
+/// Derive [`Clone`] but do not bound any generic. Docs are at `frame_support::CloneNoBound`.
+#[proc_macro_derive(CloneNoBound)]
+pub fn derive_clone_no_bound(input: TokenStream) -> TokenStream {
+	clone_no_bound::derive_clone_no_bound(input)
+}
+
+/// Derive [`Debug`] but do not bound any generics. Docs are at `frame_support::DeriveNoBounds`.
+#[proc_macro_derive(DebugNoBound)]
+pub fn derive_debug_no_bound(input: TokenStream) -> TokenStream {
+	debug_no_bound::derive_debug_no_bound(input)
+}
+
+/// Derive [`Debug`], if `std` is enabled it uses `frame_support::DebugNoBound`, if `std` is not
+/// enabled it just returns `"<stripped>"`.
+/// This behaviour is useful to prevent bloating the runtime WASM blob from unneeded code.
+#[proc_macro_derive(RuntimeDebugNoBound)]
+pub fn derive_runtime_debug_no_bound(input: TokenStream) -> TokenStream {
+	#[cfg(not(feature = "std"))]
+	{
+		let input: syn::DeriveInput = match syn::parse(input) {
+			Ok(input) => input,
+			Err(e) => return e.to_compile_error().into(),
+		};
+
+		let name = &input.ident;
+		let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+
+		quote::quote!(
+			const _: () = {
+				impl #impl_generics core::fmt::Debug for #name #ty_generics #where_clause {
+					fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
+						fmt.write_str("<stripped>")
+					}
+				}
+			};
+		).into()
+	}
+
+	#[cfg(feature = "std")]
+	{
+		debug_no_bound::derive_debug_no_bound(input)
+	}
+}
+
+/// Derive [`PartialEq`] but do not bound any generic. Docs are at
+/// `frame_support::PartialEqNoBound`.
+#[proc_macro_derive(PartialEqNoBound)]
+pub fn derive_partial_eq_no_bound(input: TokenStream) -> TokenStream {
+	partial_eq_no_bound::derive_partial_eq_no_bound(input)
+}
+
+/// derive Eq but do no bound any generic. Docs are at `frame_support::EqNoBound`.
+#[proc_macro_derive(EqNoBound)]
+pub fn derive_eq_no_bound(input: TokenStream) -> TokenStream {
+	let input: syn::DeriveInput = match syn::parse(input) {
+		Ok(input) => input,
+		Err(e) => return e.to_compile_error().into(),
+	};
+
+	let name = &input.ident;
+	let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+
+	quote::quote_spanned!(name.span() =>
+		const _: () = {
+			impl #impl_generics core::cmp::Eq for #name #ty_generics #where_clause {}
+		};
+	).into()
+}
+
 #[proc_macro_attribute]
 pub fn require_transactional(attr: TokenStream, input: TokenStream) -> TokenStream {
 	transactional::require_transactional(attr, input).unwrap_or_else(|e| e.to_compile_error().into())

substrate/frame/support/procedural/src/partial_eq_no_bound.rs

@@ -0,0 +1,126 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2020 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use syn::spanned::Spanned;
+
+/// Derive PartialEq but do not bound any generic.
+pub fn derive_partial_eq_no_bound(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	let input: syn::DeriveInput = match syn::parse(input) {
+		Ok(input) => input,
+		Err(e) => return e.to_compile_error().into(),
+	};
+
+	let name = &input.ident;
+	let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+
+	let impl_ = match input.data {
+		syn::Data::Struct(struct_) => match struct_.fields {
+			syn::Fields::Named(named) => {
+				let fields = named.named.iter()
+					.map(|i| &i.ident)
+					.map(|i| quote::quote_spanned!(i.span() => self.#i == other.#i ));
+
+				quote::quote!( true #( && #fields )* )
+			},
+			syn::Fields::Unnamed(unnamed) => {
+				let fields = unnamed.unnamed.iter().enumerate()
+					.map(|(i, _)| syn::Index::from(i))
+					.map(|i| quote::quote_spanned!(i.span() => self.#i == other.#i ));
+
+				quote::quote!( true #( && #fields )* )
+			},
+			syn::Fields::Unit => {
+				quote::quote!( true )
+			}
+		},
+		syn::Data::Enum(enum_) => {
+			let variants = enum_.variants.iter()
+				.map(|variant| {
+					let ident = &variant.ident;
+					match &variant.fields {
+						syn::Fields::Named(named) => {
+							let names = named.named.iter().map(|i| &i.ident);
+							let other_names = names.clone()
+								.enumerate()
+								.map(|(n, ident)|
+									syn::Ident::new(&format!("_{}", n), ident.span())
+								);
+
+							let capture = names.clone();
+							let other_capture = names.clone().zip(other_names.clone())
+								.map(|(i, other_i)| quote::quote!(#i: #other_i));
+							let eq = names.zip(other_names)
+								.map(|(i, other_i)| quote::quote_spanned!(i.span() => #i == #other_i));
+							quote::quote!(
+								(
+									Self::#ident { #( #capture, )* },
+									Self::#ident { #( #other_capture, )* },
+								) => true #( && #eq )*
+							)
+						},
+						syn::Fields::Unnamed(unnamed) => {
+							let names = unnamed.unnamed.iter().enumerate()
+								.map(|(i, f)| syn::Ident::new(&format!("_{}", i), f.span()));
+							let other_names = unnamed.unnamed.iter().enumerate()
+								.map(|(i, f)| syn::Ident::new(&format!("_{}_other", i), f.span()));
+							let eq = names.clone().zip(other_names.clone())
+								.map(|(i, other_i)| quote::quote_spanned!(i.span() => #i == #other_i));
+							quote::quote!(
+								(
+									Self::#ident ( #( #names, )* ),
+									Self::#ident ( #( #other_names, )* ),
+								) => true #( && #eq )*
+							)
+						},
+						syn::Fields::Unit => quote::quote!( (Self::#ident, Self::#ident) => true ),
+					}
+				});
+
+			let mut different_variants = vec![];
+			for (i, i_variant) in enum_.variants.iter().enumerate() {
+				for (j, j_variant) in enum_.variants.iter().enumerate() {
+					if i != j {
+						let i_ident = &i_variant.ident;
+						let j_ident = &j_variant.ident;
+						different_variants.push(quote::quote!(
+							(Self::#i_ident { .. }, Self::#j_ident { .. }) => false
+						))
+					}
+				}
+			}
+
+			quote::quote!( match (self, other) {
+				#( #variants, )*
+				#( #different_variants, )*
+			})
+		},
+		syn::Data::Union(_) => {
+			let msg = "Union type not supported by `derive(PartialEqNoBound)`";
+			return syn::Error::new(input.span(), msg).to_compile_error().into()
+		},
+	};
+
+	quote::quote!(
+		const _: () = {
+			impl #impl_generics core::cmp::PartialEq for #name #ty_generics #where_clause {
+				fn eq(&self, other: &Self) -> bool {
+					#impl_
+				}
+			}
+		};
+	).into()
+}

substrate/frame/support/src/lib.rs

@@ -268,9 +268,82 @@ macro_rules! ord_parameter_types {
 
 #[doc(inline)]
 pub use frame_support_procedural::{
-	decl_storage, construct_runtime, transactional
+	decl_storage, construct_runtime, transactional, RuntimeDebugNoBound
 };
 
+/// Derive [`Clone`] but do not bound any generic.
+///
+/// This is useful for type generic over runtime:
+/// ```
+/// # use frame_support::CloneNoBound;
+/// trait Trait {
+///		type C: Clone;
+/// }
+///
+/// // Foo implements [`Clone`] because `C` bounds [`Clone`].
+/// // Otherwise compilation will fail with an output telling `c` doesn't implement [`Clone`].
+/// #[derive(CloneNoBound)]
+/// struct Foo<T: Trait> {
+///		c: T::C,
+/// }
+/// ```
+pub use frame_support_procedural::CloneNoBound;
+
+/// Derive [`Eq`] but do not bound any generic.
+///
+/// This is useful for type generic over runtime:
+/// ```
+/// # use frame_support::{EqNoBound, PartialEqNoBound};
+/// trait Trait {
+///		type C: Eq;
+/// }
+///
+/// // Foo implements [`Eq`] because `C` bounds [`Eq`].
+/// // Otherwise compilation will fail with an output telling `c` doesn't implement [`Eq`].
+/// #[derive(PartialEqNoBound, EqNoBound)]
+/// struct Foo<T: Trait> {
+///		c: T::C,
+/// }
+/// ```
+pub use frame_support_procedural::EqNoBound;
+
+/// Derive [`PartialEq`] but do not bound any generic.
+///
+/// This is useful for type generic over runtime:
+/// ```
+/// # use frame_support::PartialEqNoBound;
+/// trait Trait {
+///		type C: PartialEq;
+/// }
+///
+/// // Foo implements [`PartialEq`] because `C` bounds [`PartialEq`].
+/// // Otherwise compilation will fail with an output telling `c` doesn't implement [`PartialEq`].
+/// #[derive(PartialEqNoBound)]
+/// struct Foo<T: Trait> {
+///		c: T::C,
+/// }
+/// ```
+pub use frame_support_procedural::PartialEqNoBound;
+
+/// Derive [`Debug`] but do not bound any generic.
+///
+/// This is useful for type generic over runtime:
+/// ```
+/// # use frame_support::DebugNoBound;
+/// # use core::fmt::Debug;
+/// trait Trait {
+///		type C: Debug;
+/// }
+///
+/// // Foo implements [`Debug`] because `C` bounds [`Debug`].
+/// // Otherwise compilation will fail with an output telling `c` doesn't implement [`Debug`].
+/// #[derive(DebugNoBound)]
+/// struct Foo<T: Trait> {
+///		c: T::C,
+/// }
+/// ```
+pub use frame_support_procedural::DebugNoBound;
+
 /// Assert the annotated function is executed within a storage transaction.
 ///
 /// The assertion is enabled for native execution and when `debug_assertions` are enabled.

substrate/frame/support/test/tests/derive_no_bound.rs

@@ -0,0 +1,170 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2020 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Tests for DebugNoBound, CloneNoBound, EqNoBound, PartialEqNoBound, and RuntimeDebugNoBound
+
+use frame_support::{DebugNoBound, CloneNoBound, EqNoBound, PartialEqNoBound, RuntimeDebugNoBound};
+
+#[derive(RuntimeDebugNoBound)]
+struct Unnamed(u64);
+
+#[test]
+fn runtime_debug_no_bound_display_correctly() {
+	// This test is not executed without std
+	assert_eq!(format!("{:?}", Unnamed(1)), "Unnamed(1)");
+}
+
+trait Trait {
+	type C: std::fmt::Debug + Clone + Eq + PartialEq;
+}
+
+struct Runtime;
+struct ImplNone;
+
+impl Trait for Runtime {
+	type C = u32;
+}
+
+#[derive(DebugNoBound, CloneNoBound, EqNoBound, PartialEqNoBound)]
+struct StructNamed<T: Trait, U, V> {
+	a: u32,
+	b: u64,
+	c: T::C,
+	phantom: core::marker::PhantomData<(U, V)>,
+}
+
+#[test]
+fn test_struct_named() {
+	let a_1 = StructNamed::<Runtime, ImplNone, ImplNone> {
+		a: 1,
+		b: 2,
+		c: 3,
+		phantom: Default::default(),
+	};
+
+	let a_2 = a_1.clone();
+	assert_eq!(a_2.a, 1);
+	assert_eq!(a_2.b, 2);
+	assert_eq!(a_2.c, 3);
+	assert_eq!(a_2, a_1);
+	assert_eq!(
+		format!("{:?}", a_1),
+		String::from("StructNamed { a: 1, b: 2, c: 3, phantom: PhantomData }")
+	);
+
+	let b = StructNamed::<Runtime, ImplNone, ImplNone> {
+		a: 1,
+		b: 2,
+		c: 4,
+		phantom: Default::default(),
+	};
+
+	assert!(b != a_1);
+}
+
+#[derive(DebugNoBound, CloneNoBound, EqNoBound, PartialEqNoBound)]
+struct StructUnnamed<T: Trait, U, V>(u32, u64, T::C, core::marker::PhantomData<(U, V)>);
+
+#[test]
+fn test_struct_unnamed() {
+	let a_1 = StructUnnamed::<Runtime, ImplNone, ImplNone>(
+		1,
+		2,
+		3,
+		Default::default(),
+	);
+
+	let a_2 = a_1.clone();
+	assert_eq!(a_2.0, 1);
+	assert_eq!(a_2.1, 2);
+	assert_eq!(a_2.2, 3);
+	assert_eq!(a_2, a_1);
+	assert_eq!(
+		format!("{:?}", a_1),
+		String::from("StructUnnamed(1, 2, 3, PhantomData)")
+	);
+
+	let b = StructUnnamed::<Runtime, ImplNone, ImplNone>(
+		1,
+		2,
+		4,
+		Default::default(),
+	);
+
+	assert!(b != a_1);
+}
+
+#[derive(DebugNoBound, CloneNoBound, EqNoBound, PartialEqNoBound)]
+enum Enum<T: Trait, U, V> {
+	VariantUnnamed(u32, u64, T::C, core::marker::PhantomData<(U, V)>),
+	VariantNamed {
+		a: u32,
+		b: u64,
+		c: T::C,
+		phantom: core::marker::PhantomData<(U, V)>,
+	},
+	VariantUnit,
+	VariantUnit2,
+}
+
+#[test]
+fn test_enum() {
+	type TestEnum = Enum::<Runtime, ImplNone, ImplNone>;
+	let variant_0 = TestEnum::VariantUnnamed(1, 2, 3, Default::default());
+	let variant_0_bis = TestEnum::VariantUnnamed(1, 2, 4, Default::default());
+	let variant_1 = TestEnum::VariantNamed { a: 1, b: 2, c: 3, phantom: Default::default() };
+	let variant_1_bis = TestEnum::VariantNamed { a: 1, b: 2, c: 4, phantom: Default::default() };
+	let variant_2 = TestEnum::VariantUnit;
+	let variant_3 = TestEnum::VariantUnit2;
+
+	assert!(variant_0 != variant_0_bis);
+	assert!(variant_1 != variant_1_bis);
+	assert!(variant_0 != variant_1);
+	assert!(variant_0 != variant_2);
+	assert!(variant_0 != variant_3);
+	assert!(variant_1 != variant_0);
+	assert!(variant_1 != variant_2);
+	assert!(variant_1 != variant_3);
+	assert!(variant_2 != variant_0);
+	assert!(variant_2 != variant_1);
+	assert!(variant_2 != variant_3);
+	assert!(variant_3 != variant_0);
+	assert!(variant_3 != variant_1);
+	assert!(variant_3 != variant_2);
+
+	assert!(variant_0.clone() == variant_0);
+	assert!(variant_1.clone() == variant_1);
+	assert!(variant_2.clone() == variant_2);
+	assert!(variant_3.clone() == variant_3);
+
+	assert_eq!(
+		format!("{:?}", variant_0),
+		String::from("Enum::VariantUnnamed(1, 2, 3, PhantomData)"),
+	);
+	assert_eq!(
+		format!("{:?}", variant_1),
+		String::from("Enum::VariantNamed { a: 1, b: 2, c: 3, phantom: PhantomData }"),
+	);
+	assert_eq!(
+		format!("{:?}", variant_2),
+		String::from("Enum::VariantUnit"),
+	);
+	assert_eq!(
+		format!("{:?}", variant_3),
+		String::from("Enum::VariantUnit2"),
+	);
+}

substrate/frame/support/test/tests/derive_no_bound_ui.rs

@@ -0,0 +1,26 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2020 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#[rustversion::attr(not(stable), ignore)]
+#[test]
+fn derive_no_bound_ui() {
+	// As trybuild is using `cargo check`, we don't need the real WASM binaries.
+	std::env::set_var("BUILD_DUMMY_WASM_BINARY", "1");
+
+	let t = trybuild::TestCases::new();
+	t.compile_fail("tests/derive_no_bound_ui/*.rs");
+}

substrate/frame/support/test/tests/derive_no_bound_ui/clone.rs

@@ -0,0 +1,10 @@
+trait Trait {
+	type C;
+}
+
+#[derive(frame_support::CloneNoBound)]
+struct Foo<T: Trait> {
+	c: T::C,
+}
+
+fn main() {}

substrate/frame/support/test/tests/derive_no_bound_ui/clone.stderr

@@ -0,0 +1,7 @@
+error[E0277]: the trait bound `<T as Trait>::C: std::clone::Clone` is not satisfied
+ --> $DIR/clone.rs:7:2
+  |
+7 |     c: T::C,
+  |     ^ the trait `std::clone::Clone` is not implemented for `<T as Trait>::C`
+  |
+  = note: required by `std::clone::Clone::clone`

substrate/frame/support/test/tests/derive_no_bound_ui/debug.rs

@@ -0,0 +1,10 @@
+trait Trait {
+	type C;
+}
+
+#[derive(frame_support::DebugNoBound)]
+struct Foo<T: Trait> {
+	c: T::C,
+}
+
+fn main() {}

substrate/frame/support/test/tests/derive_no_bound_ui/debug.stderr

@@ -0,0 +1,8 @@
+error[E0277]: `<T as Trait>::C` doesn't implement `std::fmt::Debug`
+ --> $DIR/debug.rs:7:2
+  |
+7 |     c: T::C,
+  |     ^ `<T as Trait>::C` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug`
+  |
+  = help: the trait `std::fmt::Debug` is not implemented for `<T as Trait>::C`
+  = note: required for the cast to the object type `dyn std::fmt::Debug`

substrate/frame/support/test/tests/derive_no_bound_ui/eq.rs

@@ -0,0 +1,10 @@
+trait Trait {
+	type C;
+}
+
+#[derive(frame_support::EqNoBound)]
+struct Foo<T: Trait> {
+	c: T::C,
+}
+
+fn main() {}

substrate/frame/support/test/tests/derive_no_bound_ui/eq.stderr

@@ -0,0 +1,7 @@
+error[E0277]: can't compare `Foo<T>` with `Foo<T>`
+   --> $DIR/eq.rs:6:8
+    |
+6   | struct Foo<T: Trait> {
+    |        ^^^ no implementation for `Foo<T> == Foo<T>`
+    |
+    = help: the trait `std::cmp::PartialEq` is not implemented for `Foo<T>`

substrate/frame/support/test/tests/derive_no_bound_ui/partial_eq.rs

@@ -0,0 +1,10 @@
+trait Trait {
+	type C;
+}
+
+#[derive(frame_support::PartialEqNoBound)]
+struct Foo<T: Trait> {
+	c: T::C,
+}
+
+fn main() {}

substrate/frame/support/test/tests/derive_no_bound_ui/partial_eq.stderr

@@ -0,0 +1,7 @@
+error[E0369]: binary operation `==` cannot be applied to type `<T as Trait>::C`
+ --> $DIR/partial_eq.rs:7:2
+  |
+7 |     c: T::C,
+  |     ^
+  |
+  = note: the trait `std::cmp::PartialEq` is not implemented for `<T as Trait>::C`