Rename Palette to FRAME (#4182)

* palette -> frame

* PALETTE, Palette -> FRAME

* Move folder pallete -> frame

* Update docs/Structure.adoc

Co-Authored-By: Benjamin Kampmann <ben.kampmann@googlemail.com>

* Update docs/README.adoc

Co-Authored-By: Benjamin Kampmann <ben.kampmann@googlemail.com>

* Update README.adoc

substrate/frame/support/procedural/tools/src/syn_ext.rs

@@ -0,0 +1,252 @@
+// Copyright 2017-2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+// tag::description[]
+//! Extension to syn types, mainly for parsing
+// end::description[]
+
+use syn::{visit::{Visit, self}, parse::{Parse, ParseStream, Result}, Ident};
+use proc_macro2::{TokenStream, TokenTree};
+use quote::ToTokens;
+use std::iter::once;
+use frame_support_procedural_tools_derive::{ToTokens, Parse};
+
+/// stop parsing here getting remaining token as content
+/// Warn duplicate stream (part of)
+#[derive(Parse, ToTokens, Debug)]
+pub struct StopParse {
+	pub inner: TokenStream,
+}
+
+// inner macro really dependant on syn naming convention, do not export
+macro_rules! groups_impl {
+	($name:ident, $tok:ident, $deli:ident, $parse:ident) => {
+
+		#[derive(Debug)]
+		pub struct $name<P> {
+			pub token: syn::token::$tok,
+			pub content: P,
+		}
+
+		impl<P: Parse> Parse for $name<P> {
+			fn parse(input: ParseStream) -> Result<Self> {
+				let syn::group::$name { token, content } = syn::group::$parse(input)?;
+				let content = content.parse()?;
+				Ok($name { token, content, })
+			}
+		}
+
+		impl<P: ToTokens> ToTokens for $name<P> {
+			fn to_tokens(&self, tokens: &mut TokenStream) {
+				let mut inner_stream = TokenStream::new();
+				self.content.to_tokens(&mut inner_stream);
+				let token_tree: proc_macro2::TokenTree =
+					proc_macro2::Group::new(proc_macro2::Delimiter::$deli, inner_stream).into();
+				tokens.extend(once(token_tree));
+			}
+		}
+
+	}
+}
+
+groups_impl!(Braces, Brace, Brace, parse_braces);
+groups_impl!(Brackets, Bracket, Bracket, parse_brackets);
+groups_impl!(Parens, Paren, Parenthesis, parse_parens);
+
+#[derive(Debug)]
+pub struct PunctuatedInner<P,T,V> {
+	pub inner: syn::punctuated::Punctuated<P,T>,
+	pub variant: V,
+}
+
+#[derive(Debug)]
+pub struct NoTrailing;
+
+
+#[derive(Debug)]
+pub struct Trailing;
+
+pub type Punctuated<P,T> = PunctuatedInner<P,T,NoTrailing>;
+
+pub type PunctuatedTrailing<P,T> = PunctuatedInner<P,T,Trailing>;
+
+impl<P: Parse, T: Parse + syn::token::Token> Parse for PunctuatedInner<P,T,Trailing> {
+	fn parse(input: ParseStream) -> Result<Self> {
+		Ok(PunctuatedInner {
+			inner: syn::punctuated::Punctuated::parse_separated_nonempty(input)?,
+			variant: Trailing,
+		})
+	}
+}
+
+impl<P: Parse, T: Parse> Parse for PunctuatedInner<P,T,NoTrailing> {
+	fn parse(input: ParseStream) -> Result<Self> {
+		Ok(PunctuatedInner {
+			inner: syn::punctuated::Punctuated::parse_terminated(input)?,
+			variant: NoTrailing,
+		})
+	}
+}
+
+impl<P: ToTokens, T: ToTokens, V> ToTokens for PunctuatedInner<P,T,V> {
+	fn to_tokens(&self, tokens: &mut TokenStream) {
+		self.inner.to_tokens(tokens)
+	}
+}
+
+/// Note that syn Meta is almost fine for use case (lacks only `ToToken`)
+#[derive(Debug, Clone)]
+pub struct Meta {
+	pub inner: syn::Meta,
+}
+
+impl Parse for Meta {
+	fn parse(input: ParseStream) -> Result<Self> {
+		Ok(Meta {
+			inner: syn::Meta::parse(input)?,
+		})
+	}
+}
+
+impl ToTokens for Meta {
+	fn to_tokens(&self, tokens: &mut TokenStream) {
+		match self.inner {
+			syn::Meta::Path(ref path) => path.to_tokens(tokens),
+			syn::Meta::List(ref l) => l.to_tokens(tokens),
+			syn::Meta::NameValue(ref n) => n.to_tokens(tokens),
+		}
+	}
+}
+
+#[derive(Debug)]
+pub struct OuterAttributes {
+	pub inner: Vec<syn::Attribute>,
+}
+
+impl Parse for OuterAttributes {
+	fn parse(input: ParseStream) -> Result<Self> {
+		let inner = syn::Attribute::parse_outer(input)?;
+		Ok(OuterAttributes {
+			inner,
+		})
+	}
+}
+
+impl ToTokens for OuterAttributes {
+	fn to_tokens(&self, tokens: &mut TokenStream) {
+		for att in self.inner.iter() {
+			att.to_tokens(tokens);
+		}
+	}
+}
+
+#[derive(Debug)]
+pub struct Opt<P> {
+	pub inner: Option<P>,
+}
+
+impl<P: Parse> Parse for Opt<P> {
+	// Note that it cost a double parsing (same as enum derive)
+	fn parse(input: ParseStream) -> Result<Self> {
+		let inner = match input.fork().parse::<P>() {
+			Ok(_item) => Some(input.parse().expect("Same parsing ran before")),
+			Err(_e) => None,
+		};
+
+		Ok(Opt { inner })
+	}
+}
+
+impl<P: ToTokens> ToTokens for Opt<P> {
+	fn to_tokens(&self, tokens: &mut TokenStream) {
+		if let Some(ref p) = self.inner {
+			p.to_tokens(tokens);
+		}
+	}
+}
+
+pub fn extract_type_option(typ: &syn::Type) -> Option<syn::Type> {
+	if let syn::Type::Path(ref path) = typ {
+		let v = path.path.segments.last()?;
+		if v.ident == "Option" {
+			// Option has only one type argument in angle bracket.
+			if let syn::PathArguments::AngleBracketed(a) = &v.arguments {
+				if let syn::GenericArgument::Type(typ) = a.args.last()? {
+					return Some(typ.clone())
+				}
+			}
+		}
+	}
+
+	None
+}
+
+/// Auxialary structure to check if a given `Ident` is contained in an ast.
+struct ContainsIdent<'a> {
+	ident: &'a Ident,
+	result: bool,
+}
+
+impl<'ast> ContainsIdent<'ast> {
+	fn visit_tokenstream(&mut self, stream: TokenStream) {
+		stream.into_iter().for_each(|tt|
+			match tt {
+				TokenTree::Ident(id) => self.visit_ident(&id),
+				TokenTree::Group(ref group) => self.visit_tokenstream(group.stream()),
+				_ => {}
+			}
+		)
+	}
+
+	fn visit_ident(&mut self, ident: &Ident) {
+		if ident == self.ident {
+			self.result = true;
+		}
+	}
+}
+
+impl<'ast> Visit<'ast> for ContainsIdent<'ast> {
+	fn visit_ident(&mut self, input: &'ast Ident) {
+		self.visit_ident(input);
+	}
+
+	fn visit_macro(&mut self, input: &'ast syn::Macro) {
+		self.visit_tokenstream(input.tokens.clone());
+		visit::visit_macro(self, input);
+	}
+}
+
+/// Check if a `Type` contains the given `Ident`.
+pub fn type_contains_ident(typ: &syn::Type, ident: &Ident) -> bool {
+	let mut visit = ContainsIdent {
+		result: false,
+		ident,
+	};
+
+	visit::visit_type(&mut visit, typ);
+	visit.result
+}
+
+/// Check if a `Expr` contains the given `Ident`.
+pub fn expr_contains_ident(expr: &syn::Expr, ident: &Ident) -> bool {
+	let mut visit = ContainsIdent {
+		result: false,
+		ident,
+	};
+
+	visit::visit_expr(&mut visit, expr);
+	visit.result
+}