ink_ir/ir/storage_item/
mod.rs

1// Copyright (C) Use Ink (UK) Ltd.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15mod config;
16
17use crate::utils::find_storage_key_salt;
18use config::StorageItemConfig;
19use proc_macro2::TokenStream as TokenStream2;
20use quote::{
21    quote,
22    ToTokens,
23};
24use std::collections::HashSet;
25
26/// A checked ink! storage item with its configuration.
27pub struct StorageItem {
28    ast: syn::DeriveInput,
29    config: StorageItemConfig,
30}
31
32impl StorageItem {
33    /// Returns `Ok` if the input matches all requirements for an ink! storage item.
34    pub fn new(config: TokenStream2, item: TokenStream2) -> Result<Self, syn::Error> {
35        let ast = syn::parse2::<syn::DeriveInput>(item)?;
36        let parsed_config = syn::parse2::<crate::ast::AttributeArgs>(config)?;
37        let config = StorageItemConfig::try_from(parsed_config)?;
38
39        for attr in &ast.attrs {
40            if attr
41                .path()
42                .to_token_stream()
43                .to_string()
44                .contains("storage_item")
45            {
46                return Err(format_err_spanned!(
47                    attr,
48                    "only one `ink::storage_item` is allowed",
49                ))
50            }
51        }
52
53        Ok(Self { ast, config })
54    }
55
56    /// Returns AST.
57    pub fn ast(&self) -> &syn::DeriveInput {
58        &self.ast
59    }
60
61    /// Returns all types that were used in the storage declaration.
62    pub fn all_used_types(&self) -> Vec<syn::Type> {
63        let res: Vec<_> = match self.data().clone() {
64            syn::Data::Struct(st) => {
65                st.fields.iter().map(|field| field.ty.clone()).collect()
66            }
67            syn::Data::Enum(en) => {
68                en.variants
69                    .iter()
70                    .flat_map(|variant| variant.fields.iter())
71                    .map(|field| field.ty.clone())
72                    .collect()
73            }
74            syn::Data::Union(un) => {
75                un.fields
76                    .named
77                    .iter()
78                    .map(|field| field.ty.clone())
79                    .collect()
80            }
81        };
82        let mut set = HashSet::new();
83        res.into_iter()
84            .filter(|ty| {
85                if !set.contains(ty) {
86                    set.insert(ty.clone());
87                    true
88                } else {
89                    false
90                }
91            })
92            .collect()
93    }
94
95    /// Returns the config of the storage.
96    pub fn config(&self) -> &StorageItemConfig {
97        &self.config
98    }
99
100    /// Returns the visibility of the storage.
101    pub fn vis(&self) -> &syn::Visibility {
102        &self.ast.vis
103    }
104
105    /// Returns the attributes of the storage.
106    pub fn attrs(&self) -> &[syn::Attribute] {
107        &self.ast.attrs
108    }
109
110    /// Returns the identifier of the storage.
111    pub fn ident(&self) -> &syn::Ident {
112        &self.ast.ident
113    }
114
115    /// Returns the generics of the storage.
116    pub fn generics(&self) -> TokenStream2 {
117        let types = self.ast.generics.clone();
118        // `where_closure` is not included into `types`, so add it manually.
119        let (_, _, where_closure) = self.ast.generics.split_for_impl();
120        quote! {
121            #types #where_closure
122        }
123    }
124
125    /// Returns data of the storage.
126    pub fn data(&self) -> &syn::Data {
127        &self.ast.data
128    }
129
130    /// Returns salt for storage key.
131    pub fn salt(&self) -> TokenStream2 {
132        if let Some(param) = find_storage_key_salt(&self.ast) {
133            param.ident.to_token_stream()
134        } else {
135            quote! { () }
136        }
137    }
138}
ink_ir/ir/storage_item/mod.rs

ink_ir/ir/storage_item/
mod.rs
