bon-macros 3.9.2

This is a proc-macro crate that is supposed to be a private implementation detail of the `bon` crate
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use super::SpannedKey;
use crate::util::prelude::*;
use darling::FromMeta;

/// "Item signature" is a set of parameters that configures some aspects of
/// an item like a function, struct, struct field, module, trait. All of them
/// have configurable properties that are specified here.
///
/// The generic parameter `N` specifies the type used for the name field:
/// - `syn::Ident` (default): For regular identifiers
/// - `String`: For pattern strings (e.g., "conv_{}")
#[derive(Debug, Clone)]
pub(crate) struct ItemSigConfig<N = syn::Ident> {
    pub(crate) name: Option<SpannedKey<N>>,
    pub(crate) vis: Option<SpannedKey<syn::Visibility>>,
    pub(crate) docs: Option<SpannedKey<Vec<syn::Attribute>>>,
}

impl<N> Default for ItemSigConfig<N> {
    fn default() -> Self {
        Self {
            name: None,
            vis: None,
            docs: None,
        }
    }
}

impl ItemSigConfig<syn::Ident> {
    pub(crate) fn name(&self) -> Option<&syn::Ident> {
        self.name.as_ref().map(|name| &name.value)
    }
}

impl<N> ItemSigConfig<N> {
    pub(crate) fn vis(&self) -> Option<&syn::Visibility> {
        self.vis.as_ref().map(|vis| &vis.value)
    }

    pub(crate) fn docs(&self) -> Option<&[syn::Attribute]> {
        self.docs.as_ref().map(|docs| docs.value.as_slice())
    }
}

pub(crate) struct ItemSigConfigParsing<'a> {
    pub(crate) meta: &'a syn::Meta,
    pub(crate) reject_self_mentions: Option<&'static str>,
}

impl<'a> ItemSigConfigParsing<'a> {
    pub(crate) fn new(meta: &'a syn::Meta, reject_self_mentions: Option<&'static str>) -> Self {
        ItemSigConfigParsing {
            meta,
            reject_self_mentions,
        }
    }

    pub(crate) fn parse<N>(self) -> Result<ItemSigConfig<N>>
    where
        N: FromMeta,
    {
        let meta = self.meta;

        if let syn::Meta::NameValue(_) = meta {
            let name = SpannedKey::from_meta(meta)?;
            return Ok(ItemSigConfig {
                name: Some(name),
                vis: None,
                docs: None,
            });
        }

        #[derive(Debug, FromMeta)]
        struct Full<N> {
            name: Option<SpannedKey<N>>,
            vis: Option<SpannedKey<syn::Visibility>>,

            #[darling(default, with = super::parse_docs, map = Some)]
            doc: Option<SpannedKey<Vec<syn::Attribute>>>,
        }

        let full: Full<N> = crate::parsing::parse_non_empty_paren_meta_list(meta)?;

        if let Some(context) = self.reject_self_mentions {
            if let Some(docs) = &full.doc {
                crate::parsing::reject_self_mentions_in_docs(context, docs)?;
            }
        }

        let config = ItemSigConfig {
            name: full.name,
            vis: full.vis,
            docs: full.doc,
        };

        Ok(config)
    }
}