xidl-parser-derive 0.97.0

A IDL codegen.
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

use super::derive_field::DeriveField;
use super::fields::Fields;
use convert_case::{Case, Casing};
use proc_macro2::Span;
use syn::LitStr;

/// Single enum variant of a Parser derive input.
#[derive(Debug)]
pub(crate) struct DerivedVariant {
    pub(crate) ident: syn::Ident,
    pub(crate) fields: Fields<DeriveField>,
    pub(crate) id: Option<String>,
}

impl DerivedVariant {
    pub(crate) fn from_variant(variant: &syn::Variant) -> syn::Result<Self> {
        let ident = variant.ident.clone();
        let mut id: Option<String> = None;

        for attr in &variant.attrs {
            if !attr.path().is_ident("ts") {
                continue;
            }
            attr.parse_nested_meta(|meta| {
                if meta.path.is_ident("text") {
                    if meta.input.peek(syn::Token![=]) {
                        let value = meta.value()?;
                        let _: syn::LitBool = value.parse()?;
                    }
                } else if meta.path.is_ident("id") {
                    let value = meta.value()?;
                    let lit: LitStr = value.parse()?;
                    id = Some(lit.value());
                } else if meta.path.is_ident("name") {
                    // accepted for compatibility, ignored for codegen
                    let value = meta.value()?;
                    let _: LitStr = value.parse()?;
                } else if meta.path.is_ident("transparent") {
                    if meta.input.peek(syn::Token![=]) {
                        let value = meta.value()?;
                        let _: syn::LitBool = value.parse()?;
                    }
                    // variant-level transparent is not used; accept for compatibility
                } else if meta.path.is_ident("mark") {
                    if meta.input.peek(syn::Token![=]) {
                        let value = meta.value()?;
                        let _: syn::LitBool = value.parse()?;
                    }
                } else {
                    return Err(meta.error(format!(
                        "unknown ts attribute `{}` on variant",
                        meta.path
                            .get_ident()
                            .map(|i| i.to_string())
                            .unwrap_or_default()
                    )));
                }
                Ok(())
            })?;
        }

        let fields = Fields::from_syn_fields(&variant.fields)?;
        Ok(Self { ident, fields, id })
    }

    /// Tree-sitter node name for this variant.
    #[inline(always)]
    pub fn ts_node_name(&self) -> LitStr {
        let id = self.id.clone().unwrap_or_else(|| {
            // FIXME: fix field(Ty)
            self.ident.to_string().to_case(Case::Snake)
        });

        LitStr::new(&id, Span::call_site())
    }
}