inktree 0.1.0

An incremental syntax tree engine for fast, expressive language tooling in Rust
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

mod delimiters;
mod extra;
mod keyword;
mod operator;
mod padding;
mod root;
mod whitespace;

use std::str::FromStr;

use derive_more::From;
use strum::{EnumDiscriminants, EnumString, EnumTryAs};
use syn::Meta;

pub use extra::*;
pub use operator::*;
pub use root::*;

use crate::{
    derive::{
        parser::FromMeta,
        properties::{
            extra::Extra,
            operator::{Infix, Postfix, Prefix},
        },
    },
    language::ElementError,
};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, EnumDiscriminants, From, EnumTryAs)]
#[strum_discriminants(vis(pub), strum(serialize_all = "snake_case"))]
#[strum_discriminants(name(PropertyKind), derive(EnumString))]
pub enum Property {
    // Keyword(Keyword),
    OpPrefix(Prefix),
    OpInfix(Infix),
    OpPostfix(Postfix),
    Root(Root),
    // Padded(Padded),
    // PaddedBy(PaddedBy),
    // DelimitedBy(DelimitedBy),
    // Whitespace(Whitespace),
    Extra(Extra),
}
impl Property {
    pub fn try_as_operator(&self) -> Option<OperatorKind> {
        match self {
            Property::OpPrefix(prefix) => Some((*prefix).into()),
            Property::OpInfix(infix) => Some((*infix).into()),
            Property::OpPostfix(postfix) => Some((*postfix).into()),
            _ => None,
        }
    }

    pub fn from_meta(meta: Meta) -> Result<Property, ElementError> {
        let kind = meta.path().get_ident().expect("asdsad");
        if let Ok(kind) = PropertyKind::from_str(&kind.to_string().as_str()) {
            Ok(kind.from_meta(&meta)?)
        } else {
            Err(syn::Error::new_spanned(kind, "unsupported todo text").into())
        }
    }
}

impl PropertyKind {
    pub fn from_meta(self, meta: &Meta) -> Result<Property, ElementError> {
        use PropertyKind as Pk;
        match self {
            // Pk::Keyword => Ok(Keyword::from_meta(meta, None)?.into()),
            Pk::Root => Ok(Root::from_meta(meta, None)?.into()),
            Pk::OpPrefix => Ok(Prefix::from_meta(meta, None)?.into()),
            Pk::OpInfix => Ok(Infix::from_meta(meta, None)?.into()),
            Pk::OpPostfix => Ok(Postfix::from_meta(meta, None)?.into()),
            // Pk::Padded => Ok(Padded::from_meta(meta, None)?.into()),
            // Pk::PaddedBy => Ok(PaddedBy::from_meta(meta, None)?.into()),
            // Pk::DelimitedBy => Ok(DelimitedBy::from_meta(meta, None)?.into()),
            // Pk::Whitespace => Ok(Whitespace::from_meta(meta, None)?.into()),
            Pk::Extra => Ok(Extra::from_meta(meta, None)?.into()),
        }
    }
}