1use crate::{ast::{ParsedEnum, ParsedField, ParsedStruct, ParsedVariant, VariantData}, token::{Delimiter, ParseError, Spacing, Span, TokenIter, TokenTree}};
2
3impl ParsedStruct {
4 pub fn parse(token_iter: &mut TokenIter) -> Result<Self, ParseError> {
5 let (name, name_span) = token_iter.expect_ident(None)?;
6 let (delimiter, fields, body_span) = token_iter.expect_group(None)?;
7 let fields: Vec<ParsedField> = match delimiter {
8 Delimiter::Brace => {
9 let mut inner_iter = TokenIter::new(fields);
10 let mut f = Vec::<ParsedField>::new();
11 while inner_iter.peek().is_some() {
12 let field = ParsedField::parse(&mut inner_iter, Delimiter::Brace)?;
13 f.push(field);
14 }
15
16 f
17 }
18 Delimiter::Parenthesis => {
19 let mut inner_iter = TokenIter::new(fields);
20 let mut f = Vec::<ParsedField>::new();
21 while inner_iter.peek().is_some() {
22 let field = ParsedField::parse(&mut inner_iter, Delimiter::Parenthesis)?;
23 f.push(field);
24 }
25
26 token_iter.expect_punct(Some(';'))?;
27
28 f
29 }
30 Delimiter::Bracket => return Err(ParseError::IncorrectDelimiter(Delimiter::Bracket, body_span)),
31 Delimiter::None => return Err(ParseError::IncorrectDelimiter(Delimiter::None, body_span))
32 };
33
34 Ok(ParsedStruct { name, fields, span: name_span })
35 }
36}
37
38impl ParsedEnum {
39 pub fn parse(token_iter: &mut TokenIter) -> Result<Self, ParseError> {
40 let (name, name_span) = token_iter.expect_ident(None)?;
41 let (delimiter, variants, body_span)= token_iter.expect_group(None)?;
42 let variants: Vec<ParsedVariant> = match delimiter {
43 Delimiter::Brace => {
44 let mut outer_iter = TokenIter::new(variants);
45 let mut v = Vec::<ParsedVariant>::new();
46 let mut index: u32 = 0;
47 while outer_iter.peek().is_some() {
48 let (name, span) = outer_iter.expect_ident(None)?;
49 if outer_iter.peek().is_none() {
50 v.push(ParsedVariant { name: name.to_owned(), index, data: VariantData::Unit(span), span });
51 }
52 else if outer_iter.peek().unwrap() == &TokenTree::Punct(',', Spacing::Alone, span) {
53 v.push(ParsedVariant { name, index, data: VariantData::Unit(span), span });
54 }
55 else {
56 let (delimiter, fields, span) = outer_iter.expect_group(None)?;
57 let data: VariantData = match delimiter {
58 Delimiter::Parenthesis => {
59 let mut inner_iter = TokenIter::new(fields);
60 let mut f = Vec::<ParsedField>::new();
61 while inner_iter.peek().is_some() {
62 let field = ParsedField::parse(&mut inner_iter, Delimiter::Parenthesis)?;
63 f.push(field);
64 }
65
66 VariantData::Tuple(f, span)
67 }
68 Delimiter::Brace => {
69 let mut inner_iter = TokenIter::new(fields);
70 let mut f = Vec::<ParsedField>::new();
71 while inner_iter.peek().is_some() {
72 let field = ParsedField::parse(&mut inner_iter, Delimiter::Brace)?;
73 f.push(field);
74 }
75
76 VariantData::Struct(f, span)
77 }
78 Delimiter::Bracket => return Err(ParseError::IncorrectDelimiter(Delimiter::Bracket, span)),
79 Delimiter::None => return Err(ParseError::IncorrectDelimiter(Delimiter::None, span))
80 };
81
82 v.push(ParsedVariant { name, index, data, span });
83 }
84
85 outer_iter.expect_punct(Some(','))?;
86 index += 1;
87 }
88
89 v
90 }
91 Delimiter::Parenthesis => return Err(ParseError::IncorrectDelimiter(Delimiter::Parenthesis, body_span)),
92 Delimiter::Bracket => return Err(ParseError::IncorrectDelimiter(Delimiter::Bracket, body_span)),
93 Delimiter::None => return Err(ParseError::IncorrectDelimiter(Delimiter::None, body_span))
94 };
95
96 Ok(ParsedEnum { name, variants, span: name_span })
97 }
98}
99
100impl ParsedField {
101 pub fn parse(token_iter: &mut TokenIter, delimiter: Delimiter) -> Result<Self, ParseError> {
102 match delimiter {
103 Delimiter::Brace => {
104 let mut ty = Vec::<TokenTree>::new();
105 let mut depth: usize = 0;
106 let (name, span) = token_iter.expect_ident(None)?;
107 token_iter.expect_punct(Some(':'))?;
108 while token_iter.peek().is_some() {
109 match token_iter.peek().unwrap() {
110 &TokenTree::Punct('<', Spacing::Alone, _) => { depth += 1; ty.push(token_iter.peek().unwrap().to_owned()); },
111 &TokenTree::Punct('>', Spacing::Alone, span) => {
112 depth.checked_sub(1).map(|_| ()).ok_or(ParseError::UnmatchedAngleBracket(span))?;
113 ty.push(token_iter.peek().unwrap().to_owned());
114 },
115 &TokenTree::Punct(',', Spacing::Alone, _) => {
116 if depth == 0 {
117 token_iter.next();
118 break;
119 }
120 else {
121 ty.push(token_iter.peek().unwrap().to_owned());
122 }
123 },
124 _ => ty.push(token_iter.peek().unwrap().to_owned())
125 }
126
127 token_iter.next();
128 }
129
130 Ok(ParsedField { name: Some(name.to_owned()), ty, span })
131 }
132 Delimiter::Parenthesis => {
133 let mut ty = Vec::<TokenTree>::new();
134 let mut depth: usize = 0;
135 while token_iter.peek().is_some() {
136 match token_iter.peek().unwrap() {
137 &TokenTree::Punct('<', Spacing::Alone, _) => { depth += 1; ty.push(token_iter.peek().unwrap().to_owned()); }
138 &TokenTree::Punct('>', Spacing::Alone, span) => {
139 depth.checked_sub(1).map(|_| ()).ok_or(ParseError::UnmatchedAngleBracket(span))?;
140 ty.push(token_iter.peek().unwrap().to_owned());
141 }
142 &TokenTree::Punct(',', Spacing::Alone, _) => {
143 if depth == 0 {
144 token_iter.next();
145 break;
146 }
147 else {
148 ty.push(token_iter.peek().unwrap().to_owned());
149 }
150 },
151 _ => ty.push(token_iter.peek().unwrap().to_owned()),
152 }
153
154 token_iter.next();
155 }
156
157 Ok(ParsedField { name: None, ty, span: Span::default()})
158 }
159 Delimiter::Bracket => return Err(ParseError::IncorrectDelimiter(Delimiter::Bracket, Span::default())),
160 Delimiter::None => return Err(ParseError::IncorrectDelimiter(Delimiter::None, Span::default()))
161 }
162 }
163}