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, _) => {
111 depth += 1;
112 ty.push(token_iter.peek().unwrap().to_owned());
113 },
114 &TokenTree::Punct('>', _, span) => {
115 depth = depth.checked_sub(1).ok_or(ParseError::UnmatchedAngleBracket(span))?;
116 ty.push(token_iter.peek().unwrap().to_owned());
117 },
118 &TokenTree::Punct(',', _, _) => {
119 if depth == 0 {
120 token_iter.next();
121 break;
122 }
123 else {
124 ty.push(token_iter.peek().unwrap().to_owned());
125 }
126 },
127 _ => ty.push(token_iter.peek().unwrap().to_owned())
128 }
129
130 token_iter.next();
131 }
132
133 Ok(ParsedField { name: Some(name.to_owned()), ty, span })
134 }
135 Delimiter::Parenthesis => {
136 let mut ty = Vec::<TokenTree>::new();
137 let mut depth: usize = 0;
138 while token_iter.peek().is_some() {
139 match token_iter.peek().unwrap() {
140 &TokenTree::Punct('<', Spacing::Alone, _) => { depth += 1; ty.push(token_iter.peek().unwrap().to_owned()); }
141 &TokenTree::Punct('>', Spacing::Alone, span) => {
142 depth = depth.checked_sub(1).ok_or(ParseError::UnmatchedAngleBracket(span))?;
143 ty.push(token_iter.peek().unwrap().to_owned());
144 }
145 &TokenTree::Punct(',', _, _) => {
146 if depth == 0 {
147 token_iter.next();
148 break;
149 }
150 else {
151 ty.push(token_iter.peek().unwrap().to_owned());
152 }
153 },
154 _ => ty.push(token_iter.peek().unwrap().to_owned()),
155 }
156
157 token_iter.next();
158 }
159
160 Ok(ParsedField { name: None, ty, span: Span::default()})
161 }
162 Delimiter::Bracket => return Err(ParseError::IncorrectDelimiter(Delimiter::Bracket, Span::default())),
163 Delimiter::None => return Err(ParseError::IncorrectDelimiter(Delimiter::None, Span::default()))
164 }
165 }
166}