git.delta.rocks / unique-network / refs/commits / 03866db9b34b

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! struct-versioning18//! The crate contains procedural macros for versioning data structures.19//! Macros `versioned` generate versioned variants of a struct.20//!21//! Example:22//! #[struct_versioning::versioned(version = 2, upper)]23//! ...24//! pub struct ItemData {25//! 	pub const_data: BoundedVec<u8, CustomDataLimit>,26//!27//! 	#[version(..2)]28//! 	pub variable_data: BoundedVec<u8, CustomDataLimit>,29//! }30//! ...31//! `#[version(..2)]` that means that any version before 2 will be upgraded to 2 via the `upper` function.32//! When version become 3 `#[struct_versioning::versioned(version = 3, upper)]` this field will be removed.33//! *upper* - generate From impls, which converts old version of structs to new34//! In this case, the upgrade is described in `on_runtime_upgrade` using the `translate_values` substrate feature35//!36//! #[pallet::hooks]37//! impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {38//! 	fn on_runtime_upgrade() -> Weight {39//! 		if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {40//! 			<TokenData<T>>::translate_values::<ItemDataVersion1, _>(|v| {41//! 				Some(<ItemDataVersion2>::from(v))42//! 			})43//! 		}44//! 		045//! 	}46//! }47//!48//! Another functionality49///50/// `#[versioned(version = 1[, first_version = 1][, upper][, versions])]`51/// - *first_version* - allows to skip generation of structs, which predates first supported version52/// - *versions* - generate enum, which contains all possible versions of struct53use proc_macro::TokenStream;54use quote::format_ident;55use syn::{56	parse::{Parse, ParseStream},57	Token, LitInt, parse_macro_input, ItemStruct, Error, Fields, Result, Field, Expr,58	parenthesized,59};60use quote::quote;6162mod kw {63	syn::custom_keyword!(version);64	syn::custom_keyword!(first_version);65	syn::custom_keyword!(versions);66	syn::custom_keyword!(upper);67}6869struct VersionedAttrs {70	current_version: u32,71	first_version: u32,72	upper: bool,73}7475/// #[versioned(version = 2)]76impl Parse for VersionedAttrs {77	fn parse(input: ParseStream) -> Result<Self> {78		let mut current_version = None::<u32>;79		let mut first_version = None::<u32>;80		let mut upper = false;8182		loop {83			if input.is_empty() {84				break;85			}86			let lookahead = input.lookahead1();87			if lookahead.peek(kw::version) {88				input.parse::<kw::version>()?;89				input.parse::<Token![=]>()?;90				let t = input.parse::<LitInt>()?;91				if current_version.is_some() {92					return Err(Error::new_spanned(t, "version is already set"));93				}94				current_version = Some(t.base10_parse()?)95			} else if lookahead.peek(kw::first_version) {96				input.parse::<kw::first_version>()?;97				input.parse::<Token![=]>()?;98				let t = input.parse::<LitInt>()?;99				if first_version.is_some() {100					return Err(Error::new_spanned(t, "first version is already set"));101				}102				first_version = Some(t.base10_parse()?)103			} else if lookahead.peek(kw::upper) {104				input.parse::<kw::upper>()?;105				upper = true;106			} else {107				return Err(lookahead.error());108			}109110			if input.is_empty() {111				break;112			} else if input.peek(Token![,]) {113				input.parse::<Token![,]>()?;114				continue;115			} else {116				return Err(input.error("unexpected token"));117			}118		}119		let first_version = first_version.unwrap_or(1);120		let current_version = current_version.unwrap_or(first_version);121122		if current_version == 0 || first_version == 0 || first_version > current_version {123			return Err(Error::new(input.span(), "1 <= first_version <= version"));124		}125126		Ok(Self {127			current_version,128			first_version,129			upper,130		})131	}132}133134/// #[version(..3)] - field vas removed in version 3 (i.e it was exist on version 2, but doesn't on version 3)135/// #[version(3..)] - field has appeared in version 3136/// #[version(2..4)] - field was on versions 2, 3137/// #[version(1..2, upper(old_field + 1))] - when updating struct from old version to new - calculate new field value from passed expression138struct VersionAttr {139	since: u32,140	before: Option<u32>,141142	upper: Option<Expr>,143}144impl VersionAttr {145	fn exists_on(&self, version: u32) -> bool {146		version >= self.since && self.before.map_or(true, |before| version < before)147	}148}149impl Parse for VersionAttr {150	fn parse(input: ParseStream) -> Result<Self> {151		let mut since = None::<u32>;152		let mut before = None::<u32>;153		let lookahead = input.lookahead1();154155		if lookahead.peek(LitInt) {156			let t: LitInt = input.parse()?;157			since = Some(t.base10_parse()?);158		} else if !lookahead.peek(Token![..]) {159			return Err(lookahead.error());160		}161		let range = input.parse::<Token![..]>()?;162		let lookahead = input.lookahead1();163		if lookahead.peek(LitInt) {164			let t: LitInt = input.parse()?;165			before = Some(t.base10_parse()?);166		} else if !input.is_empty() && !lookahead.peek(Token![,]) {167			return Err(lookahead.error());168		}169170		let upper = if input.peek(Token![,]) {171			input.parse::<Token![,]>()?;172			input.parse::<kw::upper>()?;173			let expr;174			parenthesized!(expr in input);175176			Some(Expr::parse(&expr)?)177		} else {178			None179		};180181		if since.is_none() && before.is_none() {182			return Err(Error::new_spanned(183				range,184				"noop range, remove this version attribute",185			));186		}187		Ok(Self {188			since: since.unwrap_or(1),189			before,190			upper,191		})192	}193}194impl Default for VersionAttr {195	fn default() -> Self {196		Self {197			since: 1,198			before: None,199			upper: None,200		}201	}202}203204/// Generate versioned variants of a struct205///206/// `#[versioned(version = 1[, first_version = 1][, upper][, versions])]`207/// - *version* - current version of a struct208/// - *first_version* - allows to skip generation of structs, which predates first supported version209/// - *upper* - generate From impls, which converts old version of structs to new210/// - *versions* - generate enum, which contains all possible versions of struct211///212/// Each field may have version attribute213/// `#[version([1]..[2][, upper(old)])]`214/// - *1* - version, on which this field is appeared215/// - *2* - version, in which this field was removed216/// (i.e if set to 2, this field was exist on version 1, and no longer exist on version 2)217/// - *upper* - code, which should be executed to transform old value to new/create new value218#[proc_macro_attribute]219pub fn versioned(attr: TokenStream, input: TokenStream) -> TokenStream {220	let attr = parse_macro_input!(attr as VersionedAttrs);221	let input = parse_macro_input!(input as ItemStruct);222223	let fields = match input.fields {224		Fields::Named(named) => named.named,225		_ => {226			return Error::new_spanned(input, "expected named fields")227				.into_compile_error()228				.into()229		}230	};231	let fields = fields232		.iter()233		.map(|field| {234			let version_attr = match field.attrs.iter().find(|a| a.path.is_ident("version")) {235				Some(v) => v.parse_args::<VersionAttr>()?,236				None => return Ok((VersionAttr::default(), field.clone())),237			};238			let mut field = field.clone();239			field.attrs.retain(|a| !a.path.is_ident("version"));240			Ok((version_attr, field))241		})242		.collect::<Result<Vec<(VersionAttr, Field)>>>();243	let fields = match fields {244		Ok(f) => f,245		Err(e) => return e.into_compile_error().into(),246	};247248	let attrs = input.attrs;249	let vis = input.vis;250	let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();251	let mut out = Vec::new();252	for version in attr.first_version..=attr.current_version {253		let name = if version == attr.current_version {254			input.ident.clone()255		} else {256			format_ident!("{}Version{}", &input.ident, version)257		};258		let current_fields = fields259			.iter()260			.filter_map(|(ver, field)| ver.exists_on(version).then(|| field));261262		let mut doc = Vec::new();263		if version > attr.first_version {264			doc.push(" # Versioning".into());265			doc.push(format!(" Changes between {} and {}:", version - 1, version));266			for (ver, field) in fields.iter() {267				match (ver.exists_on(version - 1), ver.exists_on(version)) {268					(true, false) => {269						let ty = &field.ty;270						doc.push(format!(271							" - {}: {} was removed",272							field.ident.as_ref().unwrap(),273							quote! {#ty}274						))275					}276					(false, true) => {277						let ty = &field.ty;278						doc.push(format!(279							" - [`{}`]: {} was added",280							field.ident.as_ref().unwrap(),281							quote! {#ty}282						))283					}284					_ => {}285				}286			}287		}288289		let upper = if attr.upper && version > attr.first_version {290			let prev_version = format_ident!("{}Version{}", &input.ident, version - 1);291			let removed_fields = fields292				.iter()293				.filter(|(v, _)| v.exists_on(version - 1) && !v.exists_on(version))294				.map(|(_, f)| f.ident.as_ref().unwrap())295				.collect::<Vec<_>>();296			let added_fields = fields297				.iter()298				.filter(|(v, _)| !v.exists_on(version - 1) && v.exists_on(version))299				.map(|(v, f)| {300					let name = f.ident.as_ref().unwrap();301					let value = v.upper.clone().unwrap_or_else(|| {302						Expr::Verbatim(303							Error::new_spanned(f, "missing upper declaration").to_compile_error(),304						)305					});306					quote! { #name: #value }307				});308			let passed_fields = fields309				.iter()310				.filter(|(v, _)| v.exists_on(version - 1) && v.exists_on(version))311				.map(|(_, f)| f.ident.as_ref().unwrap())312				.collect::<Vec<_>>();313			// let added_fields = fields;314			quote! {315				impl #impl_generics From<#prev_version #ty_generics> for #name #ty_generics #where_clause {316					fn from(old: #prev_version #ty_generics) -> Self {317						let #prev_version {318							#(#removed_fields,)*319							#(#passed_fields,)*320						} = old;321						#(let _ = &#removed_fields;)*322						Self {323							#(#added_fields,)*324							#(#passed_fields,)*325						}326					}327				}328			}329		} else {330			quote! {}331		};332333		out.push(quote! {334			#(#attrs)*335			#(#[doc = #doc])*336			#vis struct #name #impl_generics #where_clause {337				#(#current_fields,)*338			}339340			#upper341		});342	}343344	let ident = &input.ident;345	let last_version = format_ident!("{}Version{}", input.ident, attr.current_version);346347	quote! {348		#(#out)*349350		#vis type #last_version #ty_generics = #ident #ty_generics;351	}352	.into()353}