Skip to content
This repository has been archived by the owner on Nov 15, 2023. It is now read-only.

Implement ResultQuery #11257

Merged
merged 22 commits into from
Aug 24, 2022
Merged

Implement ResultQuery #11257

Show file tree
Hide file tree
Changes from 3 commits
Commits
Show all changes
22 commits
Select commit Hold shift + click to select a range
bde4b9b
Implement ResultQuery
KiChjang Apr 21, 2022
6f54457
Merge remote-tracking branch 'origin/master' into kckyeung/storage-re…
KiChjang Apr 25, 2022
4172144
Fix test expectations
KiChjang Apr 25, 2022
859c6ad
Add more tests
KiChjang Apr 28, 2022
f808d97
Fix test expectations
KiChjang Apr 28, 2022
2943838
Merge remote-tracking branch 'origin/master' into kckyeung/storage-re…
KiChjang Apr 29, 2022
1fe4727
Clean up some names
KiChjang May 11, 2022
db220d1
Silence warnings
KiChjang May 12, 2022
dd5925a
Specify error type when supplying error type to ResultQuery
KiChjang May 12, 2022
a4ba2ec
Merge remote-tracking branch 'origin/master' into kckyeung/storage-re…
KiChjang May 12, 2022
9dc6cbd
cargo fmt
KiChjang May 13, 2022
60cc317
Merge remote-tracking branch 'origin/master' into kckyeung/storage-re…
KiChjang May 13, 2022
db75bc3
Merge remote-tracking branch 'origin/master' into kckyeung/storage-re…
May 19, 2022
0d9b2d7
Merge remote-tracking branch 'origin/master' into kckyeung/storage-re…
KiChjang Aug 15, 2022
f8cbc09
Add support for type parameters in parameter_types macro
KiChjang Aug 19, 2022
4936f0c
Reduce deeply indented code
KiChjang Aug 19, 2022
9b4ba60
Fixes
KiChjang Aug 20, 2022
e5345eb
Update test expectation
KiChjang Aug 21, 2022
b1c98e3
Rewrite and document formula for calculating max storage size
KiChjang Aug 24, 2022
7ad9431
More docs
KiChjang Aug 24, 2022
46d53f7
cargo fmt
KiChjang Aug 24, 2022
17b41b5
formatting
KiChjang Aug 24, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
208 changes: 186 additions & 22 deletions frame/support/procedural/src/pallet/expand/storage.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -19,7 +19,9 @@ use crate::pallet::{
parse::storage::{Metadata, QueryKind, StorageDef, StorageGenerics},
Def,
};
use std::collections::HashMap;
use quote::ToTokens;
use std::{collections::HashMap, ops::IndexMut};
use syn::spanned::Spanned;

/// Generate the prefix_ident related to the storage.
/// prefix_ident is used for the prefix struct to be given to storage as first generic param.
Expand Down Expand Up @@ -86,12 +88,26 @@ fn check_prefix_duplicates(
Ok(())
}

pub struct OnEmptyStructMetadata {
KiChjang marked this conversation as resolved.
Show resolved Hide resolved
/// The Rust ident that is going to be used as the name of the OnEmpty struct.
pub name: syn::Ident,
/// The visibility of the OnEmpty struct.
pub visibility: syn::Visibility,
/// The type of the storage item.
pub value_ty: syn::Type,
/// The name of the pallet error enum variant that is going to be returned.
pub variant_name: syn::Ident,
/// The span used to report compilation errors about the OnEmpty struct.
pub span: proc_macro2::Span,
}

///
/// * if generics are unnamed: replace the first generic `_` by the generated prefix structure
/// * if generics are named: reorder the generic, remove their name, and add the missing ones.
/// * Add `#[allow(type_alias_bounds)]`
pub fn process_generics(def: &mut Def) -> syn::Result<()> {
pub fn process_generics(def: &mut Def) -> syn::Result<Vec<OnEmptyStructMetadata>> {
let frame_support = &def.frame_support;
let mut on_empty_struct_metadata = Vec::new();

for storage_def in def.storages.iter_mut() {
let item = &mut def.item.content.as_mut().expect("Checked by def").1[storage_def.index];
Expand Down Expand Up @@ -122,27 +138,81 @@ pub fn process_generics(def: &mut Def) -> syn::Result<()> {

let default_query_kind: syn::Type =
syn::parse_quote!(#frame_support::storage::types::OptionQuery);
let default_on_empty: syn::Type = syn::parse_quote!(#frame_support::traits::GetDefault);
let mut default_on_empty = |value_ty: syn::Type| -> syn::Type {
if let Some(QueryKind::ResultQuery(variant_name)) = storage_def.query_kind.as_ref() {
let on_empty_ident = quote::format_ident!("Get{}Result", storage_def.ident);
KiChjang marked this conversation as resolved.
Show resolved Hide resolved
on_empty_struct_metadata.push(OnEmptyStructMetadata {
name: on_empty_ident.clone(),
visibility: storage_def.vis.clone(),
value_ty,
variant_name: variant_name.clone(),
span: storage_def.attr_span,
});
return syn::parse_quote!(#on_empty_ident)
}
syn::parse_quote!(#frame_support::traits::GetDefault)
};
let default_max_values: syn::Type = syn::parse_quote!(#frame_support::traits::GetDefault);

let set_result_query_type_parameter = |query_type: &mut syn::Type| -> syn::Result<()> {
if let Some(QueryKind::ResultQuery(_)) = storage_def.query_kind.as_ref() {
let pallet_error = match def.error.as_ref() {
Some(err_def) => {
let error_ident = &err_def.error;
let ty: syn::Type = syn::parse_quote!(#error_ident<#type_use_gen>);
ty
},
None => {
let msg = "Invalid pallet::storage, ResultQuery requires a defined \
pallet::error";
return Err(syn::Error::new(storage_def.ident.span(), msg))
},
};

if let syn::Type::Path(syn::TypePath { path: syn::Path { segments, .. }, .. }) =
query_type
{
if let Some(seg) = segments.last_mut() {
if let syn::PathArguments::AngleBracketed(
syn::AngleBracketedGenericArguments { args, .. },
) = &mut seg.arguments
{
args.clear();
args.push(syn::GenericArgument::Type(pallet_error));
}
}
} else {
let msg = format!(
"Invalid pallet::storage, unexpected type for query, expected \
ResultQuery with 1 type parameter, found `{}`",
query_type.to_token_stream().to_string()
);
return Err(syn::Error::new(query_type.span(), msg))
}
}
Ok(())
};

if let Some(named_generics) = storage_def.named_generics.clone() {
args.args.clear();
args.args.push(syn::parse_quote!( #prefix_ident<#type_use_gen> ));
match named_generics {
StorageGenerics::Value { value, query_kind, on_empty } => {
args.args.push(syn::GenericArgument::Type(value));
let query_kind = query_kind.unwrap_or_else(|| default_query_kind.clone());
args.args.push(syn::GenericArgument::Type(value.clone()));
let mut query_kind = query_kind.unwrap_or_else(|| default_query_kind.clone());
set_result_query_type_parameter(&mut query_kind)?;
args.args.push(syn::GenericArgument::Type(query_kind));
let on_empty = on_empty.unwrap_or_else(|| default_on_empty.clone());
let on_empty = on_empty.unwrap_or_else(|| default_on_empty(value));
args.args.push(syn::GenericArgument::Type(on_empty));
},
StorageGenerics::Map { hasher, key, value, query_kind, on_empty, max_values } => {
args.args.push(syn::GenericArgument::Type(hasher));
args.args.push(syn::GenericArgument::Type(key));
args.args.push(syn::GenericArgument::Type(value));
let query_kind = query_kind.unwrap_or_else(|| default_query_kind.clone());
args.args.push(syn::GenericArgument::Type(value.clone()));
let mut query_kind = query_kind.unwrap_or_else(|| default_query_kind.clone());
set_result_query_type_parameter(&mut query_kind)?;
args.args.push(syn::GenericArgument::Type(query_kind));
let on_empty = on_empty.unwrap_or_else(|| default_on_empty.clone());
let on_empty = on_empty.unwrap_or_else(|| default_on_empty(value));
args.args.push(syn::GenericArgument::Type(on_empty));
let max_values = max_values.unwrap_or_else(|| default_max_values.clone());
args.args.push(syn::GenericArgument::Type(max_values));
Expand All @@ -157,10 +227,11 @@ pub fn process_generics(def: &mut Def) -> syn::Result<()> {
} => {
args.args.push(syn::GenericArgument::Type(hasher));
args.args.push(syn::GenericArgument::Type(key));
args.args.push(syn::GenericArgument::Type(value));
let query_kind = query_kind.unwrap_or_else(|| default_query_kind.clone());
args.args.push(syn::GenericArgument::Type(value.clone()));
let mut query_kind = query_kind.unwrap_or_else(|| default_query_kind.clone());
set_result_query_type_parameter(&mut query_kind)?;
args.args.push(syn::GenericArgument::Type(query_kind));
let on_empty = on_empty.unwrap_or_else(|| default_on_empty.clone());
let on_empty = on_empty.unwrap_or_else(|| default_on_empty(value));
args.args.push(syn::GenericArgument::Type(on_empty));
let max_values = max_values.unwrap_or_else(|| default_max_values.clone());
args.args.push(syn::GenericArgument::Type(max_values));
Expand All @@ -179,31 +250,76 @@ pub fn process_generics(def: &mut Def) -> syn::Result<()> {
args.args.push(syn::GenericArgument::Type(key1));
args.args.push(syn::GenericArgument::Type(hasher2));
args.args.push(syn::GenericArgument::Type(key2));
args.args.push(syn::GenericArgument::Type(value));
let query_kind = query_kind.unwrap_or_else(|| default_query_kind.clone());
args.args.push(syn::GenericArgument::Type(value.clone()));
let mut query_kind = query_kind.unwrap_or_else(|| default_query_kind.clone());
set_result_query_type_parameter(&mut query_kind)?;
args.args.push(syn::GenericArgument::Type(query_kind));
let on_empty = on_empty.unwrap_or_else(|| default_on_empty.clone());
let on_empty = on_empty.unwrap_or_else(|| default_on_empty(value));
args.args.push(syn::GenericArgument::Type(on_empty));
let max_values = max_values.unwrap_or_else(|| default_max_values.clone());
args.args.push(syn::GenericArgument::Type(max_values));
},
StorageGenerics::NMap { keygen, value, query_kind, on_empty, max_values } => {
args.args.push(syn::GenericArgument::Type(keygen));
args.args.push(syn::GenericArgument::Type(value));
let query_kind = query_kind.unwrap_or_else(|| default_query_kind.clone());
args.args.push(syn::GenericArgument::Type(value.clone()));
let mut query_kind = query_kind.unwrap_or_else(|| default_query_kind.clone());
set_result_query_type_parameter(&mut query_kind)?;
args.args.push(syn::GenericArgument::Type(query_kind));
let on_empty = on_empty.unwrap_or_else(|| default_on_empty.clone());
let on_empty = on_empty.unwrap_or_else(|| default_on_empty(value));
args.args.push(syn::GenericArgument::Type(on_empty));
let max_values = max_values.unwrap_or_else(|| default_max_values.clone());
args.args.push(syn::GenericArgument::Type(max_values));
},
}
} else {
args.args[0] = syn::parse_quote!( #prefix_ident<#type_use_gen> );

let (value_idx, query_idx, on_empty_idx) = match storage_def.metadata {
Metadata::Value { .. } => (1, 2, 3),
Metadata::NMap { .. } => (2, 3, 4),
Metadata::Map { .. } | Metadata::CountedMap { .. } => (3, 4, 5),
Metadata::DoubleMap { .. } => (5, 6, 7),
};

// #FIXME: Really stupid, the index and index_mut methods on syn::Punctuated don't
KiChjang marked this conversation as resolved.
Show resolved Hide resolved
// return Options so we have to manually check whether they're over the length limit.
if query_idx < args.args.len() {
if let syn::GenericArgument::Type(query_kind) = args.args.index_mut(query_idx) {
set_result_query_type_parameter(query_kind)?;
}
} else if let Some(QueryKind::ResultQuery(_)) = storage_def.query_kind.as_ref() {
let pallet_error = match def.error.as_ref() {
Some(err_def) => {
let error_ident = &err_def.error;
let ty: syn::Type = syn::parse_quote!(#error_ident<#type_use_gen>);
ty
},
None => {
let msg = "Invalid pallet::storage, ResultQuery requires a defined \
pallet::error";
return Err(syn::Error::new(storage_def.ident.span(), msg))
},
};

args.args.push(syn::GenericArgument::Type(pallet_error))
}

// Here, we only need to check if OnEmpty is *not* specified, and if so, then we have to
// generate a default OnEmpty struct for it.
if on_empty_idx >= args.args.len() &&
matches!(storage_def.query_kind.as_ref(), Some(QueryKind::ResultQuery(_)))
{
let value_ty = match args.args[value_idx].clone() {
syn::GenericArgument::Type(ty) => ty,
_ => unreachable!(),
};
let on_empty = default_on_empty(value_ty);
args.args.push(syn::GenericArgument::Type(on_empty));
}
}
}

Ok(())
Ok(on_empty_struct_metadata)
}

///
Expand All @@ -214,9 +330,10 @@ pub fn process_generics(def: &mut Def) -> syn::Result<()> {
/// * Add `#[allow(type_alias_bounds)]` on storages type alias
/// * generate metadatas
pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
if let Err(e) = process_generics(def) {
return e.into_compile_error().into()
}
let on_empty_struct_metadata = match process_generics(def) {
Ok(idents) => idents,
Err(e) => return e.into_compile_error().into(),
};

// Check for duplicate prefixes
let mut prefix_set = HashMap::new();
Expand Down Expand Up @@ -271,6 +388,13 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
let type_use_gen = &def.type_use_generics(storage.attr_span);
let full_ident = quote::quote_spanned!(storage.attr_span => #ident<#gen> );

let pallet_error = def.error.as_ref().map(|err_def| {
let error_ident = &err_def.error;
quote::quote_spanned!(err_def.attr_span =>
#error_ident<#type_use_gen>
)
});

let cfg_attrs = &storage.cfg_attrs;

match &storage.metadata {
Expand All @@ -279,6 +403,9 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
QueryKind::OptionQuery => quote::quote_spanned!(storage.attr_span =>
Option<#value>
),
QueryKind::ResultQuery(_) => quote::quote_spanned!(storage.attr_span =>
Result<#value, #pallet_error>
),
QueryKind::ValueQuery => quote::quote!(#value),
};
quote::quote_spanned!(storage.attr_span =>
Expand All @@ -298,6 +425,9 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
QueryKind::OptionQuery => quote::quote_spanned!(storage.attr_span =>
Option<#value>
),
QueryKind::ResultQuery(_) => quote::quote_spanned!(storage.attr_span =>
Result<#value, #pallet_error>
),
QueryKind::ValueQuery => quote::quote!(#value),
};
quote::quote_spanned!(storage.attr_span =>
Expand All @@ -319,6 +449,9 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
QueryKind::OptionQuery => quote::quote_spanned!(storage.attr_span =>
Option<#value>
),
QueryKind::ResultQuery(_) => quote::quote_spanned!(storage.attr_span =>
Result<#value, #pallet_error>
),
QueryKind::ValueQuery => quote::quote!(#value),
};
quote::quote_spanned!(storage.attr_span =>
Expand All @@ -340,6 +473,9 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
QueryKind::OptionQuery => quote::quote_spanned!(storage.attr_span =>
Option<#value>
),
QueryKind::ResultQuery(_) => quote::quote_spanned!(storage.attr_span =>
Result<#value, #pallet_error>
),
QueryKind::ValueQuery => quote::quote!(#value),
};
quote::quote_spanned!(storage.attr_span =>
Expand All @@ -363,6 +499,9 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
QueryKind::OptionQuery => quote::quote_spanned!(storage.attr_span =>
Option<#value>
),
QueryKind::ResultQuery(_) => quote::quote_spanned!(storage.attr_span =>
Result<#value, #pallet_error>
),
QueryKind::ValueQuery => quote::quote!(#value),
};
quote::quote_spanned!(storage.attr_span =>
Expand Down Expand Up @@ -461,6 +600,30 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
)
});

let on_empty_structs = on_empty_struct_metadata
.into_iter()
.map(|OnEmptyStructMetadata { name, visibility, value_ty, variant_name, span }| {
let type_impl_gen = &def.type_impl_generics(span);
let type_use_gen = &def.type_use_generics(span);
let pallet_error = def.error.as_ref().expect("Checked in process_generics; qed");
let pallet_error_ident = &pallet_error.error;
let config_where_clause = &def.config.where_clause;

quote::quote_spanned!(span =>
#[doc(hidden)]
#visibility struct #name;

impl<#type_impl_gen> #frame_support::traits::Get<Result<#value_ty, #pallet_error_ident<#type_use_gen>>>
for #name
#config_where_clause
{
fn get() -> Result<#value_ty, #pallet_error_ident<#type_use_gen>> {
Err(#pallet_error_ident::<#type_use_gen>::#variant_name)
}
}
)
});

let mut where_clauses = vec![&def.config.where_clause];
where_clauses.extend(def.storages.iter().map(|storage| &storage.where_clause));
let completed_where_clause = super::merge_where_clauses(&where_clauses);
Expand Down Expand Up @@ -491,5 +654,6 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {

#( #getters )*
#( #prefix_structs )*
#( #on_empty_structs )*
)
}
Loading