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 name: Pattern::Path(false, Path(vec![Identifier(String::from("self"))])),
216 type_: Some(TypeExpr(
217 TypeExprKind::Path(Path(vec![Identifier(String::from("Self"))])),
218 vec![TypePostfix::RefMut],
219 )),
220 }];
221
222 constructor_params.append(&mut self.1.item.params.0.clone());
223
224 Spanned {
225 line: self.1.line,
226 column: self.1.column,
227 item: FunctionDecl {
228 visibility: self.1.item.visibility.clone(),
229 name: Identifier(String::from("constructor")),
230 generics: self.1.item.generics.clone(),
231 params: ParamList(constructor_params),
232 return_type: TypeExpr::no_px(TypeExprKind::Tuple(Vec::new())),
233 body: Some(self.1.item.body.clone()),
234 },
235 }
236 .gen_rust(ctx, cg);
237 }
238}
239
240impl GenRust for TopLevelKind {
241 fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
242 match self {
243 Self::ModAttribute => {}
244 Self::Import(vis, path) => {
245 cg.addln(&format!("{}use {};", vis.get_rust(), path.get_rust()))
246 }
247 Self::Mod(vis, id) => cg.addln(&format!("{}mod {};", vis.get_rust(), id.get_rust())),
248 Self::FunctionDecl(decl) => decl.gen_rust(ctx, cg),
249 Self::ImplDecl(impl_) => impl_.gen_rust(ctx, cg),
250 Self::StructDecl {
251 visibility,
252 name,
253 generics,
254 fields,
255 } => {
256 cg.addln(&format!(
257 "{}struct {}{} {{",
258 visibility.get_rust(),
259 name.get_rust(),
260 generics.get_rust()
261 ));
262 cg.indent += 1;
263
264 for field in fields {
265 cg.add_indentedln(&field.get_rust());
266 }
267
268 cg.indent -= 1;
269 cg.addln("}\n");
270 }
271 Self::EnumDecl {
272 visibility,
273 name,
274 generics,
275 fields,
276 } => {
277 cg.addln(&format!(
278 "{}enum {}{} {{",
279 visibility.get_rust(),
280 name.get_rust(),
281 generics.get_rust()
282 ));
283 cg.indent += 1;
284
285 for field in fields {
286 cg.add_indentedln(&(field.get_rust() + ","));
287 }
288
289 cg.indent -= 1;
290 cg.addln("}\n");
291 }
292 Self::TraitDecl {
293 visibility,
294 name,
295 generics,
296 requirements,
297 items,
298 } => {
299 cg.addln(&format!(
300 "{}trait {}{}{} {{",
301 visibility.get_rust(),
302 name.get_rust(),
303 generics.get_rust(),
304 if requirements.len() != 0 {
305 String::from(": ")
306 + &requirements
307 .into_iter()
308 .map(TypeExpr::get_rust)
309 .collect::<Vec<_>>()
310 .join("+")
311 } else {
312 String::new()
313 },
314 ));
315 cg.indent += 1;
316
317 for item in items {
318 item.gen_rust(ctx, cg);
319 }
320
321 cg.indent -= 1;
322 cg.addln("}\n");
323 }
324 Self::ClassDecl {
325 visibility,
326 name,
327 generics,
328 inherits,
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 if let Some(inherits) = inherits {
343 cg.add_indented("pub _super: ");
344 cg.add(&inherits.get_rust());
345 cg.addln(",");
346 }
347
348 for field in fields.clone() {
349 cg.add_indentedln(&field.get_comment());
350 cg.add_indentedln(&field.item.decl.get_rust());
351 }
352
353 cg.indent -= 1;
354 cg.addln("}\n");
355
356 cg.addln(&format!(
358 "impl{} {}{} {{",
359 generics.clone().get_rust(),
360 name.clone().get_rust(),
361 format!(
362 "<{}>",
363 generics
364 .clone()
365 .0
366 .into_iter()
367 .map(|v| Generic::from(v).get_rust())
368 .collect::<Vec<_>>()
369 .join(", ")
370 )
371 ));
372 cg.indent += 1;
373
374 let constructor_comment = constructor.get_comment();
375
376 cg.add_indentedln("#[allow(invalid_value)]");
377 cg.add_indentedln(&constructor_comment);
378
379 (fields, constructor).gen_rust(ctx, cg);
380
381 for item in items.clone() {
382 match item {
383 ClassItem::ImplDecl(_) => {}
384 ClassItem::Method(method) => method.gen_rust(ctx, cg),
385 }
386 }
387
388 cg.indent -= 1;
389 cg.addln("}\n");
390
391 for item in items {
392 match item {
393 ClassItem::ImplDecl(impl_) => {
394 let mut impl_ = impl_.clone();
395
396 impl_.item.trait_ = Some(impl_.item.target);
397 impl_.item.target =
398 TypeExpr(TypeExprKind::Path(Path(vec![name.clone()])), Vec::new());
399
400 impl_.gen_rust(ctx, cg);
401 }
402 ClassItem::Method(_) => {}
403 }
404 }
405
406 if let Some(inherits) = inherits {
407 cg.add("impl std::ops::Deref for ");
408 cg.add(&name.get_rust());
409
410 cg.addln(" {");
411 cg.indent += 1;
412
413 cg.add_indented("type Target = ");
414 cg.add(&inherits.get_rust());
415 cg.addln(";");
416
417 cg.add_indentedln("fn deref(&self) -> &Self::Target {&self._super}");
418
419 cg.indent -= 1;
420 cg.addln("}");
421
422 cg.add("impl std::ops::DerefMut for ");
425 cg.add(&name.get_rust());
426
427 cg.addln(" {");
428 cg.indent += 1;
429
430 cg.add_indentedln(
431 "fn deref_mut(&mut self) -> &mut Self::Target {&mut self._super}",
432 );
433
434 cg.indent -= 1;
435 cg.addln("}");
436 }
437 }
438 }
439 }
440}