fix: Complete snowbridge pezpallet rebrand and critical bug fixes
- snowbridge-pezpallet-* → pezsnowbridge-pezpallet-* (201 refs) - pallet/ directories → pezpallet/ (4 locations) - Fixed pezpallet.rs self-include recursion bug - Fixed sc-chain-spec hardcoded crate name in derive macro - Reverted .pezpallet_by_name() to .pallet_by_name() (subxt API) - Added BizinikiwiConfig type alias for zombienet tests - Deleted obsolete session state files Verified: pezsnowbridge-pezpallet-*, pezpallet-staking, pezpallet-staking-async, pezframe-benchmarking-cli all pass cargo check
This commit is contained in:
@@ -0,0 +1,645 @@
|
||||
// This file is part of Bizinikiwi.
|
||||
|
||||
// Copyright (C) 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 proc_macro2::TokenStream;
|
||||
use quote::{quote, ToTokens};
|
||||
use syn::spanned::Spanned;
|
||||
|
||||
/// List of additional token to be used for parsing.
|
||||
mod keyword {
|
||||
syn::custom_keyword!(I);
|
||||
syn::custom_keyword!(compact);
|
||||
syn::custom_keyword!(GenesisBuild);
|
||||
syn::custom_keyword!(BuildGenesisConfig);
|
||||
syn::custom_keyword!(Config);
|
||||
syn::custom_keyword!(T);
|
||||
syn::custom_keyword!(Pezpallet);
|
||||
syn::custom_keyword!(origin);
|
||||
syn::custom_keyword!(DispatchResult);
|
||||
syn::custom_keyword!(DispatchResultWithPostInfo);
|
||||
}
|
||||
|
||||
/// A usage of instance, either the trait `Config` has been used with instance or without instance.
|
||||
/// Used to check for consistency.
|
||||
#[derive(Clone)]
|
||||
pub struct InstanceUsage {
|
||||
pub has_instance: bool,
|
||||
pub span: proc_macro2::Span,
|
||||
}
|
||||
|
||||
/// Trait implemented for syn items to get mutable references on their attributes.
|
||||
///
|
||||
/// NOTE: verbatim variants are not supported.
|
||||
pub trait MutItemAttrs {
|
||||
fn mut_item_attrs(&mut self) -> Option<&mut Vec<syn::Attribute>>;
|
||||
}
|
||||
|
||||
/// Take the first pezpallet attribute (e.g. attribute like `#[pezpallet..]`) and decode it to `Attr`
|
||||
pub(crate) fn take_first_item_pallet_attr<Attr>(
|
||||
item: &mut impl MutItemAttrs,
|
||||
) -> syn::Result<Option<Attr>>
|
||||
where
|
||||
Attr: syn::parse::Parse,
|
||||
{
|
||||
let Some(attrs) = item.mut_item_attrs() else { return Ok(None) };
|
||||
|
||||
let Some(index) = attrs.iter().position(|attr| {
|
||||
attr.path().segments.first().map_or(false, |segment| segment.ident == "pezpallet")
|
||||
}) else {
|
||||
return Ok(None);
|
||||
};
|
||||
|
||||
let pezpallet_attr = attrs.remove(index);
|
||||
Ok(Some(syn::parse2(pezpallet_attr.into_token_stream())?))
|
||||
}
|
||||
|
||||
/// Take all the pezpallet attributes (e.g. attribute like `#[pezpallet..]`) and decode them to `Attr`
|
||||
pub(crate) fn take_item_pallet_attrs<Attr>(item: &mut impl MutItemAttrs) -> syn::Result<Vec<Attr>>
|
||||
where
|
||||
Attr: syn::parse::Parse,
|
||||
{
|
||||
let mut pezpallet_attrs = Vec::new();
|
||||
|
||||
while let Some(attr) = take_first_item_pallet_attr(item)? {
|
||||
pezpallet_attrs.push(attr)
|
||||
}
|
||||
|
||||
Ok(pezpallet_attrs)
|
||||
}
|
||||
|
||||
/// Get all the cfg attributes (e.g. attribute like `#[cfg..]`) and decode them to `Attr`
|
||||
pub fn get_item_cfg_attrs(attrs: &[syn::Attribute]) -> Vec<syn::Attribute> {
|
||||
attrs
|
||||
.iter()
|
||||
.filter_map(|attr| {
|
||||
if attr.path().segments.first().map_or(false, |segment| segment.ident == "cfg") {
|
||||
Some(attr.clone())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
}
|
||||
|
||||
impl MutItemAttrs for syn::Item {
|
||||
fn mut_item_attrs(&mut self) -> Option<&mut Vec<syn::Attribute>> {
|
||||
match self {
|
||||
Self::Const(item) => Some(item.attrs.as_mut()),
|
||||
Self::Enum(item) => Some(item.attrs.as_mut()),
|
||||
Self::ExternCrate(item) => Some(item.attrs.as_mut()),
|
||||
Self::Fn(item) => Some(item.attrs.as_mut()),
|
||||
Self::ForeignMod(item) => Some(item.attrs.as_mut()),
|
||||
Self::Impl(item) => Some(item.attrs.as_mut()),
|
||||
Self::Macro(item) => Some(item.attrs.as_mut()),
|
||||
Self::Mod(item) => Some(item.attrs.as_mut()),
|
||||
Self::Static(item) => Some(item.attrs.as_mut()),
|
||||
Self::Struct(item) => Some(item.attrs.as_mut()),
|
||||
Self::Trait(item) => Some(item.attrs.as_mut()),
|
||||
Self::TraitAlias(item) => Some(item.attrs.as_mut()),
|
||||
Self::Type(item) => Some(item.attrs.as_mut()),
|
||||
Self::Union(item) => Some(item.attrs.as_mut()),
|
||||
Self::Use(item) => Some(item.attrs.as_mut()),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl MutItemAttrs for syn::TraitItem {
|
||||
fn mut_item_attrs(&mut self) -> Option<&mut Vec<syn::Attribute>> {
|
||||
match self {
|
||||
Self::Const(item) => Some(item.attrs.as_mut()),
|
||||
Self::Fn(item) => Some(item.attrs.as_mut()),
|
||||
Self::Type(item) => Some(item.attrs.as_mut()),
|
||||
Self::Macro(item) => Some(item.attrs.as_mut()),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl MutItemAttrs for Vec<syn::Attribute> {
|
||||
fn mut_item_attrs(&mut self) -> Option<&mut Vec<syn::Attribute>> {
|
||||
Some(self)
|
||||
}
|
||||
}
|
||||
|
||||
impl MutItemAttrs for syn::ItemMod {
|
||||
fn mut_item_attrs(&mut self) -> Option<&mut Vec<syn::Attribute>> {
|
||||
Some(&mut self.attrs)
|
||||
}
|
||||
}
|
||||
|
||||
impl MutItemAttrs for syn::ImplItemFn {
|
||||
fn mut_item_attrs(&mut self) -> Option<&mut Vec<syn::Attribute>> {
|
||||
Some(&mut self.attrs)
|
||||
}
|
||||
}
|
||||
|
||||
impl MutItemAttrs for syn::ItemType {
|
||||
fn mut_item_attrs(&mut self) -> Option<&mut Vec<syn::Attribute>> {
|
||||
Some(&mut self.attrs)
|
||||
}
|
||||
}
|
||||
|
||||
/// Parse for `()`
|
||||
struct Unit;
|
||||
impl syn::parse::Parse for Unit {
|
||||
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
|
||||
let content;
|
||||
syn::parenthesized!(content in input);
|
||||
if !content.is_empty() {
|
||||
let msg = "unexpected tokens, expected nothing inside parenthesis as `()`";
|
||||
return Err(syn::Error::new(content.span(), msg));
|
||||
}
|
||||
Ok(Self)
|
||||
}
|
||||
}
|
||||
|
||||
/// Parse for `'static`
|
||||
struct StaticLifetime;
|
||||
impl syn::parse::Parse for StaticLifetime {
|
||||
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
|
||||
let lifetime = input.parse::<syn::Lifetime>()?;
|
||||
if lifetime.ident != "static" {
|
||||
let msg = "unexpected tokens, expected `static`";
|
||||
return Err(syn::Error::new(lifetime.ident.span(), msg));
|
||||
}
|
||||
Ok(Self)
|
||||
}
|
||||
}
|
||||
|
||||
/// Check the syntax: `I: 'static = ()`
|
||||
///
|
||||
/// `span` is used in case generics is empty (empty generics has span == call_site).
|
||||
///
|
||||
/// return the instance if found.
|
||||
pub fn check_config_def_gen(gen: &syn::Generics, span: proc_macro2::Span) -> syn::Result<()> {
|
||||
let expected = "expected `I: 'static = ()`";
|
||||
pub struct CheckTraitDefGenerics;
|
||||
impl syn::parse::Parse for CheckTraitDefGenerics {
|
||||
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
|
||||
input.parse::<keyword::I>()?;
|
||||
input.parse::<syn::Token![:]>()?;
|
||||
input.parse::<StaticLifetime>()?;
|
||||
input.parse::<syn::Token![=]>()?;
|
||||
input.parse::<Unit>()?;
|
||||
|
||||
Ok(Self)
|
||||
}
|
||||
}
|
||||
|
||||
syn::parse2::<CheckTraitDefGenerics>(gen.params.to_token_stream()).map_err(|e| {
|
||||
let msg = format!("Invalid generics: {}", expected);
|
||||
let mut err = syn::Error::new(span, msg);
|
||||
err.combine(e);
|
||||
err
|
||||
})?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Check the syntax:
|
||||
/// * either `T`
|
||||
/// * or `T, I = ()`
|
||||
///
|
||||
/// `span` is used in case generics is empty (empty generics has span == call_site).
|
||||
///
|
||||
/// return the instance if found.
|
||||
pub fn check_type_def_gen_no_bounds(
|
||||
gen: &syn::Generics,
|
||||
span: proc_macro2::Span,
|
||||
) -> syn::Result<InstanceUsage> {
|
||||
let expected = "expected `T` or `T, I = ()`";
|
||||
pub struct Checker(InstanceUsage);
|
||||
impl syn::parse::Parse for Checker {
|
||||
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
|
||||
let mut instance_usage = InstanceUsage { has_instance: false, span: input.span() };
|
||||
|
||||
input.parse::<keyword::T>()?;
|
||||
if input.peek(syn::Token![,]) {
|
||||
instance_usage.has_instance = true;
|
||||
input.parse::<syn::Token![,]>()?;
|
||||
input.parse::<keyword::I>()?;
|
||||
input.parse::<syn::Token![=]>()?;
|
||||
input.parse::<Unit>()?;
|
||||
}
|
||||
|
||||
Ok(Self(instance_usage))
|
||||
}
|
||||
}
|
||||
|
||||
let i = syn::parse2::<Checker>(gen.params.to_token_stream())
|
||||
.map_err(|e| {
|
||||
let msg = format!("Invalid type def generics: {}", expected);
|
||||
let mut err = syn::Error::new(span, msg);
|
||||
err.combine(e);
|
||||
err
|
||||
})?
|
||||
.0;
|
||||
|
||||
Ok(i)
|
||||
}
|
||||
|
||||
/// Check the syntax:
|
||||
/// * either `` (no generics
|
||||
/// * or `T`
|
||||
/// * or `T: Config`
|
||||
/// * or `T, I = ()`
|
||||
/// * or `T: Config<I>, I: 'static = ()`
|
||||
///
|
||||
/// `span` is used in case generics is empty (empty generics has span == call_site).
|
||||
///
|
||||
/// return some instance usage if there is some generic, or none otherwise.
|
||||
pub fn check_type_def_optional_gen(
|
||||
gen: &syn::Generics,
|
||||
span: proc_macro2::Span,
|
||||
) -> syn::Result<Option<InstanceUsage>> {
|
||||
let expected = "expected `` or `T` or `T: Config` or `T, I = ()` or \
|
||||
`T: Config<I>, I: 'static = ()`";
|
||||
pub struct Checker(Option<InstanceUsage>);
|
||||
impl syn::parse::Parse for Checker {
|
||||
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
|
||||
if input.is_empty() {
|
||||
return Ok(Self(None));
|
||||
}
|
||||
|
||||
let mut instance_usage = InstanceUsage { span: input.span(), has_instance: false };
|
||||
|
||||
input.parse::<keyword::T>()?;
|
||||
|
||||
if input.is_empty() {
|
||||
return Ok(Self(Some(instance_usage)));
|
||||
}
|
||||
|
||||
let lookahead = input.lookahead1();
|
||||
if lookahead.peek(syn::Token![,]) {
|
||||
instance_usage.has_instance = true;
|
||||
input.parse::<syn::Token![,]>()?;
|
||||
input.parse::<keyword::I>()?;
|
||||
input.parse::<syn::Token![=]>()?;
|
||||
input.parse::<Unit>()?;
|
||||
|
||||
Ok(Self(Some(instance_usage)))
|
||||
} else if lookahead.peek(syn::Token![:]) {
|
||||
input.parse::<syn::Token![:]>()?;
|
||||
input.parse::<keyword::Config>()?;
|
||||
|
||||
if input.is_empty() {
|
||||
return Ok(Self(Some(instance_usage)));
|
||||
}
|
||||
|
||||
instance_usage.has_instance = true;
|
||||
input.parse::<syn::Token![<]>()?;
|
||||
input.parse::<keyword::I>()?;
|
||||
input.parse::<syn::Token![>]>()?;
|
||||
input.parse::<syn::Token![,]>()?;
|
||||
input.parse::<keyword::I>()?;
|
||||
input.parse::<syn::Token![:]>()?;
|
||||
input.parse::<StaticLifetime>()?;
|
||||
input.parse::<syn::Token![=]>()?;
|
||||
input.parse::<Unit>()?;
|
||||
|
||||
Ok(Self(Some(instance_usage)))
|
||||
} else {
|
||||
Err(lookahead.error())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let i = syn::parse2::<Checker>(gen.params.to_token_stream())
|
||||
.map_err(|e| {
|
||||
let msg = format!("Invalid type def generics: {}", expected);
|
||||
let mut err = syn::Error::new(span, msg);
|
||||
err.combine(e);
|
||||
err
|
||||
})?
|
||||
.0
|
||||
// Span can be call_site if generic is empty. Thus we replace it.
|
||||
.map(|mut i| {
|
||||
i.span = span;
|
||||
i
|
||||
});
|
||||
|
||||
Ok(i)
|
||||
}
|
||||
|
||||
/// Check the syntax:
|
||||
/// * either `Pezpallet<T>`
|
||||
/// * or `Pezpallet<T, I>`
|
||||
///
|
||||
/// return the instance if found.
|
||||
pub fn check_pallet_struct_usage(type_: &Box<syn::Type>) -> syn::Result<InstanceUsage> {
|
||||
let expected = "expected `Pezpallet<T>` or `Pezpallet<T, I>`";
|
||||
pub struct Checker(InstanceUsage);
|
||||
impl syn::parse::Parse for Checker {
|
||||
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
|
||||
let mut instance_usage = InstanceUsage { span: input.span(), has_instance: false };
|
||||
|
||||
input.parse::<keyword::Pezpallet>()?;
|
||||
input.parse::<syn::Token![<]>()?;
|
||||
input.parse::<keyword::T>()?;
|
||||
if input.peek(syn::Token![,]) {
|
||||
instance_usage.has_instance = true;
|
||||
input.parse::<syn::Token![,]>()?;
|
||||
input.parse::<keyword::I>()?;
|
||||
}
|
||||
input.parse::<syn::Token![>]>()?;
|
||||
|
||||
Ok(Self(instance_usage))
|
||||
}
|
||||
}
|
||||
|
||||
let i = syn::parse2::<Checker>(type_.to_token_stream())
|
||||
.map_err(|e| {
|
||||
let msg = format!("Invalid pezpallet struct: {}", expected);
|
||||
let mut err = syn::Error::new(type_.span(), msg);
|
||||
err.combine(e);
|
||||
err
|
||||
})?
|
||||
.0;
|
||||
|
||||
Ok(i)
|
||||
}
|
||||
|
||||
/// Check the generic is:
|
||||
/// * either `T: Config`
|
||||
/// * or `T: Config<I>, I: 'static`
|
||||
///
|
||||
/// `span` is used in case generics is empty (empty generics has span == call_site).
|
||||
///
|
||||
/// return whether it contains instance.
|
||||
pub fn check_impl_gen(gen: &syn::Generics, span: proc_macro2::Span) -> syn::Result<InstanceUsage> {
|
||||
let expected = "expected `impl<T: Config>` or `impl<T: Config<I>, I: 'static>`";
|
||||
pub struct Checker(InstanceUsage);
|
||||
impl syn::parse::Parse for Checker {
|
||||
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
|
||||
let mut instance_usage = InstanceUsage { span: input.span(), has_instance: false };
|
||||
|
||||
input.parse::<keyword::T>()?;
|
||||
input.parse::<syn::Token![:]>()?;
|
||||
input.parse::<keyword::Config>()?;
|
||||
if input.peek(syn::Token![<]) {
|
||||
instance_usage.has_instance = true;
|
||||
input.parse::<syn::Token![<]>()?;
|
||||
input.parse::<keyword::I>()?;
|
||||
input.parse::<syn::Token![>]>()?;
|
||||
input.parse::<syn::Token![,]>()?;
|
||||
input.parse::<keyword::I>()?;
|
||||
input.parse::<syn::Token![:]>()?;
|
||||
input.parse::<StaticLifetime>()?;
|
||||
}
|
||||
|
||||
Ok(Self(instance_usage))
|
||||
}
|
||||
}
|
||||
|
||||
let i = syn::parse2::<Checker>(gen.params.to_token_stream())
|
||||
.map_err(|e| {
|
||||
let mut err = syn::Error::new(span, format!("Invalid generics: {}", expected));
|
||||
err.combine(e);
|
||||
err
|
||||
})?
|
||||
.0;
|
||||
|
||||
Ok(i)
|
||||
}
|
||||
|
||||
/// Check the syntax:
|
||||
/// * or `T`
|
||||
/// * or `T: Config`
|
||||
/// * or `T, I = ()`
|
||||
/// * or `T: Config<I>, I: 'static = ()`
|
||||
///
|
||||
/// `span` is used in case generics is empty (empty generics has span == call_site).
|
||||
///
|
||||
/// return the instance if found.
|
||||
pub fn check_type_def_gen(
|
||||
gen: &syn::Generics,
|
||||
span: proc_macro2::Span,
|
||||
) -> syn::Result<InstanceUsage> {
|
||||
let expected = "expected `T` or `T: Config` or `T, I = ()` or \
|
||||
`T: Config<I>, I: 'static = ()`";
|
||||
pub struct Checker(InstanceUsage);
|
||||
impl syn::parse::Parse for Checker {
|
||||
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
|
||||
let mut instance_usage = InstanceUsage { span: input.span(), has_instance: false };
|
||||
|
||||
input.parse::<keyword::T>()?;
|
||||
|
||||
if input.is_empty() {
|
||||
return Ok(Self(instance_usage));
|
||||
}
|
||||
|
||||
let lookahead = input.lookahead1();
|
||||
if lookahead.peek(syn::Token![,]) {
|
||||
instance_usage.has_instance = true;
|
||||
input.parse::<syn::Token![,]>()?;
|
||||
input.parse::<keyword::I>()?;
|
||||
input.parse::<syn::Token![=]>()?;
|
||||
input.parse::<Unit>()?;
|
||||
|
||||
Ok(Self(instance_usage))
|
||||
} else if lookahead.peek(syn::Token![:]) {
|
||||
input.parse::<syn::Token![:]>()?;
|
||||
input.parse::<keyword::Config>()?;
|
||||
|
||||
if input.is_empty() {
|
||||
return Ok(Self(instance_usage));
|
||||
}
|
||||
|
||||
instance_usage.has_instance = true;
|
||||
input.parse::<syn::Token![<]>()?;
|
||||
input.parse::<keyword::I>()?;
|
||||
input.parse::<syn::Token![>]>()?;
|
||||
input.parse::<syn::Token![,]>()?;
|
||||
input.parse::<keyword::I>()?;
|
||||
input.parse::<syn::Token![:]>()?;
|
||||
input.parse::<StaticLifetime>()?;
|
||||
input.parse::<syn::Token![=]>()?;
|
||||
input.parse::<Unit>()?;
|
||||
|
||||
Ok(Self(instance_usage))
|
||||
} else {
|
||||
Err(lookahead.error())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let mut i = syn::parse2::<Checker>(gen.params.to_token_stream())
|
||||
.map_err(|e| {
|
||||
let msg = format!("Invalid type def generics: {}", expected);
|
||||
let mut err = syn::Error::new(span, msg);
|
||||
err.combine(e);
|
||||
err
|
||||
})?
|
||||
.0;
|
||||
|
||||
// Span can be call_site if generic is empty. Thus we replace it.
|
||||
i.span = span;
|
||||
|
||||
Ok(i)
|
||||
}
|
||||
|
||||
/// Check the syntax:
|
||||
/// * either `GenesisBuild<T>`
|
||||
/// * or `GenesisBuild<T, I>`
|
||||
/// * or `BuildGenesisConfig`
|
||||
///
|
||||
/// return the instance if found for `GenesisBuild`
|
||||
/// return None for BuildGenesisConfig
|
||||
pub fn check_genesis_builder_usage(type_: &syn::Path) -> syn::Result<Option<InstanceUsage>> {
|
||||
let expected = "expected `BuildGenesisConfig` (or the deprecated `GenesisBuild<T>` or `GenesisBuild<T, I>`)";
|
||||
pub struct Checker(Option<InstanceUsage>);
|
||||
impl syn::parse::Parse for Checker {
|
||||
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
|
||||
let mut instance_usage = InstanceUsage { span: input.span(), has_instance: false };
|
||||
|
||||
if input.peek(keyword::GenesisBuild) {
|
||||
input.parse::<keyword::GenesisBuild>()?;
|
||||
input.parse::<syn::Token![<]>()?;
|
||||
input.parse::<keyword::T>()?;
|
||||
if input.peek(syn::Token![,]) {
|
||||
instance_usage.has_instance = true;
|
||||
input.parse::<syn::Token![,]>()?;
|
||||
input.parse::<keyword::I>()?;
|
||||
}
|
||||
input.parse::<syn::Token![>]>()?;
|
||||
return Ok(Self(Some(instance_usage)));
|
||||
} else {
|
||||
input.parse::<keyword::BuildGenesisConfig>()?;
|
||||
return Ok(Self(None));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let i = syn::parse2::<Checker>(type_.to_token_stream())
|
||||
.map_err(|e| {
|
||||
let msg = format!("Invalid genesis builder: {}", expected);
|
||||
let mut err = syn::Error::new(type_.span(), msg);
|
||||
err.combine(e);
|
||||
err
|
||||
})?
|
||||
.0;
|
||||
|
||||
Ok(i)
|
||||
}
|
||||
|
||||
/// Check the syntax:
|
||||
/// * either `` (no generics)
|
||||
/// * or `T: Config`
|
||||
/// * or `T: Config<I>, I: 'static`
|
||||
///
|
||||
/// `span` is used in case generics is empty (empty generics has span == call_site).
|
||||
///
|
||||
/// return the instance if found.
|
||||
pub fn check_type_value_gen(
|
||||
gen: &syn::Generics,
|
||||
span: proc_macro2::Span,
|
||||
) -> syn::Result<Option<InstanceUsage>> {
|
||||
let expected = "expected `` or `T: Config` or `T: Config<I>, I: 'static`";
|
||||
pub struct Checker(Option<InstanceUsage>);
|
||||
impl syn::parse::Parse for Checker {
|
||||
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
|
||||
if input.is_empty() {
|
||||
return Ok(Self(None));
|
||||
}
|
||||
|
||||
input.parse::<keyword::T>()?;
|
||||
input.parse::<syn::Token![:]>()?;
|
||||
input.parse::<keyword::Config>()?;
|
||||
|
||||
let mut instance_usage = InstanceUsage { span: input.span(), has_instance: false };
|
||||
|
||||
if input.is_empty() {
|
||||
return Ok(Self(Some(instance_usage)));
|
||||
}
|
||||
|
||||
instance_usage.has_instance = true;
|
||||
input.parse::<syn::Token![<]>()?;
|
||||
input.parse::<keyword::I>()?;
|
||||
input.parse::<syn::Token![>]>()?;
|
||||
input.parse::<syn::Token![,]>()?;
|
||||
input.parse::<keyword::I>()?;
|
||||
input.parse::<syn::Token![:]>()?;
|
||||
input.parse::<StaticLifetime>()?;
|
||||
|
||||
Ok(Self(Some(instance_usage)))
|
||||
}
|
||||
}
|
||||
|
||||
let i = syn::parse2::<Checker>(gen.params.to_token_stream())
|
||||
.map_err(|e| {
|
||||
let msg = format!("Invalid type def generics: {}", expected);
|
||||
let mut err = syn::Error::new(span, msg);
|
||||
err.combine(e);
|
||||
err
|
||||
})?
|
||||
.0
|
||||
// Span can be call_site if generic is empty. Thus we replace it.
|
||||
.map(|mut i| {
|
||||
i.span = span;
|
||||
i
|
||||
});
|
||||
|
||||
Ok(i)
|
||||
}
|
||||
|
||||
/// The possible return type of a dispatchable.
|
||||
#[derive(Clone)]
|
||||
pub enum CallReturnType {
|
||||
DispatchResult,
|
||||
DispatchResultWithPostInfo,
|
||||
}
|
||||
|
||||
/// Check the keyword `DispatchResultWithPostInfo` or `DispatchResult`.
|
||||
pub fn check_pallet_call_return_type(sig: &syn::Signature) -> syn::Result<CallReturnType> {
|
||||
let syn::ReturnType::Type(_, type_) = &sig.output else {
|
||||
let msg = "Invalid pezpallet::call, require return type \
|
||||
DispatchResultWithPostInfo";
|
||||
return Err(syn::Error::new(sig.span(), msg));
|
||||
};
|
||||
|
||||
pub struct Checker(CallReturnType);
|
||||
impl syn::parse::Parse for Checker {
|
||||
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
|
||||
let lookahead = input.lookahead1();
|
||||
if lookahead.peek(keyword::DispatchResultWithPostInfo) {
|
||||
input.parse::<keyword::DispatchResultWithPostInfo>()?;
|
||||
Ok(Self(CallReturnType::DispatchResultWithPostInfo))
|
||||
} else if lookahead.peek(keyword::DispatchResult) {
|
||||
input.parse::<keyword::DispatchResult>()?;
|
||||
Ok(Self(CallReturnType::DispatchResult))
|
||||
} else {
|
||||
Err(lookahead.error())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
syn::parse2::<Checker>(type_.to_token_stream()).map(|c| c.0)
|
||||
}
|
||||
|
||||
pub(crate) fn two128_str(s: &str) -> TokenStream {
|
||||
bytes_to_array(pezsp_crypto_hashing::twox_128(s.as_bytes()).into_iter())
|
||||
}
|
||||
|
||||
pub(crate) fn bytes_to_array(bytes: impl IntoIterator<Item = u8>) -> TokenStream {
|
||||
let bytes = bytes.into_iter();
|
||||
|
||||
quote!(
|
||||
[ #( #bytes ),* ]
|
||||
)
|
||||
.into()
|
||||
}
|
||||
Reference in New Issue
Block a user