1use mist_parser::ast::*;
2
3use crate::Context;
4
5use crate::{GenRust, GetRust, RustCodegen};
6
7impl GetRust for GenericsDecl {
8 fn get_rust(&self) -> String {
9 if self.0.len() == 0 {
10 String::new()
11 } else {
12 format!(
13 "<{}>",
14 self.0
15 .iter()
16 .map(|v| v.get_rust())
17 .collect::<Vec<_>>()
18 .join(", ")
19 )
20 }
21 }
22}
23
24impl GetRust for GenericDecl {
25 fn get_rust(&self) -> String {
26 match self {
27 GenericDecl::Lifetime(name) => format!("'{}", name.get_rust()),
28 GenericDecl::Type(name, requirements) => {
29 name.get_rust()
30 + &(if requirements.len() != 0 {
31 format!(
32 ": {}",
33 requirements
34 .into_iter()
35 .map(TypeExpr::get_rust)
36 .collect::<Vec<_>>()
37 .join("+")
38 )
39 } else {
40 String::new()
41 })
42 }
43 }
44 }
45}
46
47impl GenRust for ImplDecl {
48 fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
49 if let Some(trait_) = &self.trait_ {
50 cg.add_indentedln(&format!(
51 "impl{} {} for {} {{",
52 self.generics.get_rust(),
53 trait_.get_rust(),
54 self.target.get_rust()
55 ));
56 } else {
57 cg.add_indentedln(&format!(
58 "impl{} {} {{",
59 self.generics.get_rust(),
60 self.target.get_rust()
61 ));
62 }
63 cg.indent += 1;
64
65 for method in &self.methods {
66 method.gen_rust(ctx, cg);
67 }
68
69 cg.indent -= 1;
70 cg.add_indentedln("}");
71 }
72}
73
74impl GenRust for FunctionDecl {
75 fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
76 cg.add(&format!(
77 "{}fn {}{}(",
78 self.visibility.get_rust(),
79 self.name.get_rust(),
80 self.generics.get_rust(),
81 ));
82
83 for (i, param) in self.params.0.iter().enumerate() {
84 if i > 0 {
85 cg.add(", ");
86 }
87
88 param.gen_rust(ctx, cg);
89 }
90
91 cg.add(") -> ");
92 cg.add(&self.return_type.get_rust());
93
94 if let Some(body) = &self.body {
95 cg.add(" ");
96 body.gen_rust(ctx, cg);
97 } else {
98 cg.add(";");
99 }
100 }
101}
102
103impl GetRust for FieldDecl {
104 fn get_rust(&self) -> String {
105 format!(
106 "{}{}: {},",
107 self.visibility.get_rust(),
108 self.name.get_rust(),
109 self.type_.get_rust()
110 )
111 }
112}
113
114impl GetRust for EnumItem {
115 fn get_rust(&self) -> String {
116 match self {
117 Self::Named(id) => id.get_rust(),
118 Self::Struct(id, s) => format!(
119 "{} {{{}}}",
120 id.get_rust(),
121 s.into_iter()
122 .map(|field| format!("{}: {}", field.name.get_rust(), field.type_.get_rust()))
123 .collect::<Vec<_>>()
124 .join(", ")
125 ),
126 Self::Tuple(id, t) => format!(
127 "{} ({})",
128 id.get_rust(),
129 t.into_iter()
130 .map(TypeExpr::get_rust)
131 .collect::<Vec<_>>()
132 .join(", ")
133 ),
134 }
135 }
136}
137
138impl GenRust for ParamList {
139 fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
140 for (i, param) in self.0.iter().enumerate() {
141 if i > 0 {
142 cg.add(", ");
143 }
144
145 param.gen_rust(ctx, cg);
146 }
147 }
148}
149
150impl GenRust for TopLevel {
151 fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
152 if let TopLevelKind::ModAttribute = self.0.item {
153 for attr in &self.1 {
154 cg.add("#![");
155 attr.gen_rust(ctx, cg);
156 cg.addln("]");
157 }
158 } else {
159 for attr in &self.1 {
160 cg.add("#[");
161 attr.gen_rust(ctx, cg);
162 cg.addln("]");
163 }
164 }
165
166 self.0.gen_rust(ctx, cg);
167 }
168}
169
170impl GenRust for (&Vec<Spanned<FieldDeclStmt>>, &Spanned<ClassConstructor>) {
171 fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
172 cg.add_indented(&format!(
173 "{}fn new{}(",
174 self.1.item.visibility.get_rust(),
175 self.1.item.generics.get_rust()
176 ));
177
178 self.1.item.params.gen_rust(ctx, cg);
179
180 cg.addln(") -> Self {");
181 cg.indent += 1;
182
183 cg.add_indentedln("let mut this: Self = unsafe { std::mem::MaybeUninit::<Self>::zeroed().assume_init() };");
184
185 for field in self.0 {
186 let comment = field.get_comment();
187
188 if let Some(init) = &field.item.init {
189 cg.add_indentedln(&comment);
190
191 cg.add_indentedln(&format!("this.{} = ", field.item.decl.name.get_rust()));
192
193 init.gen_rust(ctx, cg);
194 }
195 }
196
197 cg.add_indented(&format!("this.constructor("));
198
199 for (i, param) in self.1.item.params.0.iter().enumerate() {
200 if i > 0 {
201 cg.add(", ");
202 }
203
204 param.name.gen_rust(ctx, cg);
205 }
206
207 cg.addln(");");
208
209 cg.add_indentedln("this");
210
211 cg.indent -= 1;
212 cg.add_indentedln("}\n");
213
214 let mut constructor_params = vec![VarDecl {
215 mutable: false,
216 name: Pattern::Id(Identifier(String::from("self"))),
217 type_: Some(TypeExpr(
218 TypeExprKind::Path(Path(vec![Identifier(String::from("Self"))])),
219 vec![TypePostfix::RefMut],
220 )),
221 }];
222
223 constructor_params.append(&mut self.1.item.params.0.clone());
224
225 Spanned {
226 line: self.1.line,
227 column: self.1.column,
228 item: FunctionDecl {
229 visibility: self.1.item.visibility.clone(),
230 name: Identifier(String::from("constructor")),
231 generics: self.1.item.generics.clone(),
232 params: ParamList(constructor_params),
233 return_type: TypeExpr::no_px(TypeExprKind::Tuple(Vec::new())),
234 body: Some(self.1.item.body.clone()),
235 },
236 }
237 .gen_rust(ctx, cg);
238 }
239}
240
241impl GenRust for TopLevelKind {
242 fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
243 match self {
244 Self::ModAttribute => {}
245 Self::Import(vis, path) => {
246 cg.addln(&format!("{}use {};", vis.get_rust(), path.get_rust()))
247 }
248 Self::Mod(vis, id) => cg.addln(&format!("{}mod {};", vis.get_rust(), id.get_rust())),
249 Self::FunctionDecl(decl) => decl.gen_rust(ctx, cg),
250 Self::ImplDecl(impl_) => impl_.gen_rust(ctx, cg),
251 Self::StructDecl {
252 visibility,
253 name,
254 generics,
255 fields,
256 } => {
257 cg.addln(&format!(
258 "{}struct {}{} {{",
259 visibility.get_rust(),
260 name.get_rust(),
261 generics.get_rust()
262 ));
263 cg.indent += 1;
264
265 for field in fields {
266 cg.add_indentedln(&field.get_rust());
267 }
268
269 cg.indent -= 1;
270 cg.addln("}\n");
271 }
272 Self::EnumDecl {
273 visibility,
274 name,
275 generics,
276 fields,
277 } => {
278 cg.addln(&format!(
279 "{}enum {}{} {{",
280 visibility.get_rust(),
281 name.get_rust(),
282 generics.get_rust()
283 ));
284 cg.indent += 1;
285
286 for field in fields {
287 cg.add_indentedln(&(field.get_rust() + ","));
288 }
289
290 cg.indent -= 1;
291 cg.addln("}\n");
292 }
293 Self::TraitDecl {
294 visibility,
295 name,
296 generics,
297 requirements,
298 items,
299 } => {
300 cg.addln(&format!(
301 "{}trait {}{}{} {{",
302 visibility.get_rust(),
303 name.get_rust(),
304 generics.get_rust(),
305 if requirements.len() != 0 {
306 String::from(": ")
307 + &requirements
308 .into_iter()
309 .map(TypeExpr::get_rust)
310 .collect::<Vec<_>>()
311 .join("+")
312 } else {
313 String::new()
314 },
315 ));
316 cg.indent += 1;
317
318 for item in items {
319 item.gen_rust(ctx, cg);
320 }
321
322 cg.indent -= 1;
323 cg.addln("}\n");
324 }
325 Self::ClassDecl {
326 visibility,
327 name,
328 generics,
329 fields,
330 constructor,
331 items,
332 } => {
333 cg.addln(&format!(
335 "{}struct {}{} {{",
336 visibility.get_rust(),
337 name.clone().get_rust(),
338 generics.clone().get_rust()
339 ));
340 cg.indent += 1;
341
342 for field in fields.clone() {
343 cg.add_indentedln(&field.get_comment());
344 cg.add_indentedln(&field.item.decl.get_rust());
345 }
346
347 cg.indent -= 1;
348 cg.addln("}\n");
349
350 cg.addln(&format!(
352 "impl{} {}{} {{",
353 generics.clone().get_rust(),
354 name.clone().get_rust(),
355 format!(
356 "<{}>",
357 generics
358 .clone()
359 .0
360 .into_iter()
361 .map(|v| Generic::from(v).get_rust())
362 .collect::<Vec<_>>()
363 .join(", ")
364 )
365 ));
366 cg.indent += 1;
367
368 let constructor_comment = constructor.get_comment();
369
370 cg.add_indentedln("#[allow(invalid_value)]");
371 cg.add_indentedln(&constructor_comment);
372
373 (fields, constructor).gen_rust(ctx, cg);
374
375 for item in items.clone() {
376 match item {
377 ClassItem::ImplDecl(_) => {}
378 ClassItem::Method(method) => method.gen_rust(ctx, cg),
379 }
380 }
381
382 cg.indent -= 1;
383 cg.addln("}\n");
384
385 for item in items {
386 match item {
387 ClassItem::ImplDecl(impl_) => {
388 let mut impl_ = impl_.clone();
389
390 impl_.item.trait_ = Some(impl_.item.target);
391 impl_.item.target =
392 TypeExpr(TypeExprKind::Path(Path(vec![name.clone()])), Vec::new());
393
394 impl_.gen_rust(ctx, cg);
395 }
396 ClassItem::Method(_) => {}
397 }
398 }
399 }
400 }
401 }
402}