ink_ir/ir/
utils.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
15use super::Selector;
16use crate::{
17    ast,
18    ast::MetaNameValue,
19    error::ExtError as _,
20    format_err,
21};
22use proc_macro2::Span;
23use std::collections::HashMap;
24use syn::spanned::Spanned;
25
26/// Ensures that the given visibility is `pub` and otherwise returns an appropriate error.
27///
28/// # Note
29///
30/// The `name` parameter is given to improve the resulting error message. It denotes the
31/// entity which cannot have non-public visibility.
32pub fn ensure_pub_visibility(
33    name: &str,
34    parent_span: Span,
35    vis: &syn::Visibility,
36) -> Result<(), syn::Error> {
37    let bad_visibility = match vis {
38        syn::Visibility::Inherited => Some(parent_span),
39        syn::Visibility::Restricted(vis_restricted) => Some(vis_restricted.span()),
40        syn::Visibility::Public(_) => None,
41    };
42    if let Some(bad_visibility) = bad_visibility {
43        return Err(format_err!(
44            bad_visibility,
45            "non `pub` ink! {} are not supported",
46            name
47        ))
48    }
49    Ok(())
50}
51
52/// Returns a local ID unique to the ink! trait definition for the identifier.
53///
54/// # Note
55///
56/// - The returned value is equal to the selector of the message identifier.
57/// - Used from within ink! trait definitions as well as ink! trait implementation blocks.
58pub fn local_message_id(ident: &syn::Ident) -> u32 {
59    let input = ident.to_string().into_bytes();
60    let selector = Selector::compute(&input);
61    selector.into_be_u32()
62}
63
64/// The set of attributes that can be passed to call builder or call forwarder in the
65/// codegen.
66#[derive(Debug, PartialEq, Eq)]
67pub struct WhitelistedAttributes(pub HashMap<String, ()>);
68
69impl Default for WhitelistedAttributes {
70    fn default() -> Self {
71        Self(HashMap::from([
72            // Conditional compilation
73            ("cfg".to_string(), ()),
74            ("cfg_attr".to_string(), ()),
75            // Diagnostics
76            ("allow".to_string(), ()),
77            ("warn".to_string(), ()),
78            ("deny".to_string(), ()),
79            ("forbid".to_string(), ()),
80            ("deprecated".to_string(), ()),
81            ("must_use".to_string(), ()),
82            // Documentation
83            ("doc".to_string(), ()),
84            // Formatting
85            ("rustfmt".to_string(), ()),
86        ]))
87    }
88}
89
90impl WhitelistedAttributes {
91    /// Parses the `MetaNameValue` argument of `keep_attr` attribute. If the argument has
92    /// a correct format `"foo, bar"` then `foo`, `bar` will be included in
93    /// the whitelist of attributes. Else error about parsing will be returned.
94    pub fn parse_arg_value(&mut self, arg: &MetaNameValue) -> Result<(), syn::Error> {
95        if let ast::MetaValue::Lit(syn::Lit::Str(attributes)) = &arg.value {
96            attributes.value().split(',').for_each(|attribute| {
97                self.0.insert(attribute.trim().to_string(), ());
98            });
99            Ok(())
100        } else {
101            Err(format_err_spanned!(
102                arg,
103                "expected a string with attributes separated by `,`",
104            ))
105        }
106    }
107
108    /// Returns the filtered input vector of whitelisted attributes.
109    /// All not whitelisted attributes are removed.
110    pub fn filter_attr(&self, attrs: Vec<syn::Attribute>) -> Vec<syn::Attribute> {
111        attrs
112            .into_iter()
113            .filter(|attr| {
114                if let Some(ident) = attr.path().get_ident() {
115                    self.0.contains_key(&ident.to_string())
116                } else {
117                    false
118                }
119            })
120            .collect()
121    }
122}
123
124/// Return an error to notify about duplicate ink! configuration arguments.
125pub fn duplicate_config_err<F, S>(
126    first: F,
127    second: S,
128    name: &str,
129    ink_attr: &str,
130) -> syn::Error
131where
132    F: Spanned,
133    S: Spanned,
134{
135    format_err!(
136        second.span(),
137        "encountered duplicate ink! {} `{}` configuration argument",
138        ink_attr,
139        name,
140    )
141    .into_combine(format_err!(
142        first.span(),
143        "first `{}` configuration argument here",
144        name
145    ))
146}
147
148/// Finds the salt of a struct, enum or union.
149/// The salt is any generic that has bound `StorageKey`.
150/// In most cases it is the parent storage key or the auto-generated storage key.
151pub fn find_storage_key_salt(input: &syn::DeriveInput) -> Option<syn::TypeParam> {
152    input.generics.params.iter().find_map(|param| {
153        if let syn::GenericParam::Type(type_param) = param {
154            if let Some(syn::TypeParamBound::Trait(trait_bound)) =
155                type_param.bounds.first()
156            {
157                let segments = &trait_bound.path.segments;
158                if let Some(last) = segments.last() {
159                    if last.ident == "StorageKey" {
160                        return Some(type_param.clone())
161                    }
162                }
163            }
164        }
165        None
166    })
167}
168
169/// Extracts `cfg` attributes from the given set of attributes
170pub fn extract_cfg_attributes(
171    attrs: &[syn::Attribute],
172    span: Span,
173) -> Vec<proc_macro2::TokenStream> {
174    attrs
175        .iter()
176        .filter(|a| a.path().is_ident(super::CFG_IDENT))
177        .map(|a| quote::quote_spanned!(span=> #a ))
178        .collect()
179}
180
181/// Extracts `cfg` attributes from the given set of attributes
182pub fn extract_cfg_syn_attributes(attrs: &[syn::Attribute]) -> Vec<syn::Attribute> {
183    attrs
184        .iter()
185        .filter(|a| a.path().is_ident(super::CFG_IDENT))
186        .cloned()
187        .collect()
188}
ink_ir/ir/utils.rs

ink_ir/ir/
utils.rs
