Skip to main content

moxy_ast/member/
mod.rs

1mod foreign_item;
2mod impl_item;
3mod trait_item;
4
5pub use foreign_item::*;
6pub use impl_item::*;
7pub use trait_item::*;
8
9use moxy_token::{Ident, Lit, Span, Spanner, ToTokens, TokenStream};
10
11use crate::*;
12
13/// A struct/tuple field accessor — a named field (`.field`) or a tuple index (`.0`).
14#[derive(Clone)]
15#[cfg_attr(feature = "derives", derive(Debug, PartialEq, Eq))]
16#[cfg_attr(feature = "serde", derive(serde::Serialize))]
17pub enum Member {
18    Named(Ident),
19    Unnamed(Lit),
20}
21
22impl Member {
23    pub fn is_named(&self) -> bool {
24        matches!(self, Self::Named(_))
25    }
26
27    pub fn is_unnamed(&self) -> bool {
28        matches!(self, Self::Unnamed(_))
29    }
30
31    pub fn as_named(&self) -> Option<&Ident> {
32        if let Self::Named(v) = self { Some(v) } else { None }
33    }
34
35    pub fn as_unnamed(&self) -> Option<&Lit> {
36        if let Self::Unnamed(v) = self { Some(v) } else { None }
37    }
38}
39
40impl From<Ident> for Member {
41    fn from(v: Ident) -> Self {
42        Self::Named(v)
43    }
44}
45
46impl From<u32> for Member {
47    fn from(v: u32) -> Self {
48        Self::Unnamed(Lit::u32_unsuffixed(v))
49    }
50}
51
52impl Spanner for Member {
53    fn span(&self) -> Span {
54        match self {
55            Self::Named(id) => id.span(),
56            Self::Unnamed(idx) => idx.span(),
57        }
58    }
59}
60
61impl Parse for Member {
62    fn peek(cursor: Cursor<'_>) -> bool {
63        if Ident::peek(cursor) {
64            return true;
65        }
66
67        let Some(moxy_token::TokenTree::Literal(Lit::Int(value))) = cursor.curr() else {
68            return false;
69        };
70
71        value.repr().chars().all(char::is_numeric) && value.value() <= 4294967295
72    }
73
74    fn parse(parser: &Parser) -> Result<Self, ParseError> {
75        if Lit::peek(parser.cursor()) {
76            let lit: Lit = <_ as Parse>::parse(parser)?;
77
78            if let Some(i) = lit.as_int() {
79                if !i.repr().chars().all(char::is_numeric) {
80                    parser.error("expected tuple index").into()
81                } else if i.value() > 4294967295 {
82                    parser.error("tuple index exceeds max size 4294967295").into()
83                } else {
84                    Ok(Self::Unnamed(lit))
85                }
86            } else {
87                parser.error("expected tuple index").into()
88            }
89        } else {
90            Ok(Self::Named(<_ as Parse>::parse(parser)?))
91        }
92    }
93
94    fn skip(cursor: Cursor<'_>) -> Option<Cursor<'_>> {
95        if !Self::peek(cursor) {
96            return None;
97        }
98
99        if Lit::peek(cursor) {
100            Lit::skip(cursor)
101        } else {
102            Ident::skip(cursor)
103        }
104    }
105}
106
107impl ToTokens for Member {
108    fn to_tokens(&self, tokens: &mut TokenStream) {
109        match self {
110            Self::Named(ident) => ident.to_tokens(tokens),
111            Self::Unnamed(idx) => idx.to_tokens(tokens),
112        }
113    }
114}