@samitouri / QOS-React-2 / commits / 90c3a3866d

[rust] Improve estree serialization

Updates to use our own codegen'd `Serialize` implementation for AST node types. Notably, this allows us to ensure that we always emit a `type` field, even when the type is obvious from context (serde doesn't do this) and avoid double-emitting `type` fields (which serde can do if you try to force a tag to be emitted). We still use the Deserialize impl because it works fine for our purposes.

Joe Savona committed Jul 25, 2023 at 15:16 UTC 90c3a3866d59c76b504d5e6c87a64a71ee6641d0
7 files changed +1292 -140
compiler/forget/crates/forget_estree/src/generated.rs
+1205 -111
@@ -1,6 +1,7 @@
1 // @generated
2 #![cfg_attr(rustfmt, rustfmt_skip)]
3 use std::num::NonZeroU32;
4 +use serde::ser::{Serializer, SerializeMap};
5 use serde::{Serialize, Deserialize};
6 use crate::{JsValue, Binding, SourceRange};
7 #[derive(Serialize, Deserialize, Clone, Debug)]
@@ -35,7 +36,7 @@ pub struct RegExpValue {
36 pub pattern: String,
37 pub flags: String,
38 }
38 -#[derive(Serialize, Deserialize, Clone, Debug)]
39 +#[derive(Deserialize, Clone, Debug)]
40 pub struct Identifier {
41 pub name: String,
42 #[serde(skip)]
@@ -46,7 +47,20 @@ pub struct Identifier {
47 #[serde(default)]
48 pub range: Option<SourceRange>,
49 }
49 -#[derive(Serialize, Deserialize, Clone, Debug)]
50 +impl Serialize for Identifier {
51 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
52 + where
53 + S: Serializer,
54 + {
55 + let mut state = serializer.serialize_map(None)?;
56 + state.serialize_entry("type", "Identifier")?;
57 + state.serialize_entry("name", &self.name)?;
58 + state.serialize_entry("loc", &self.loc)?;
59 + state.serialize_entry("range", &self.range)?;
60 + state.end()
61 + }
62 +}
63 +#[derive(Deserialize, Clone, Debug)]
64 pub struct Literal {
65 pub value: JsValue,
66 #[serde(default)]
@@ -58,7 +72,22 @@ pub struct Literal {
72 #[serde(default)]
73 pub range: Option<SourceRange>,
74 }
61 -#[derive(Serialize, Deserialize, Clone, Debug)]
75 +impl Serialize for Literal {
76 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
77 + where
78 + S: Serializer,
79 + {
80 + let mut state = serializer.serialize_map(None)?;
81 + state.serialize_entry("type", "Literal")?;
82 + state.serialize_entry("value", &self.value)?;
83 + state.serialize_entry("raw", &self.raw)?;
84 + state.serialize_entry("regex", &self.regex)?;
85 + state.serialize_entry("loc", &self.loc)?;
86 + state.serialize_entry("range", &self.range)?;
87 + state.end()
88 + }
89 +}
90 +#[derive(Deserialize, Clone, Debug)]
91 pub struct Program {
92 pub body: Vec<ModuleItem>,
93 #[serde(rename = "sourceType")]
@@ -69,7 +98,21 @@ pub struct Program {
98 #[serde(default)]
99 pub range: Option<SourceRange>,
100 }
72 -#[derive(Serialize, Deserialize, Clone, Debug)]
101 +impl Serialize for Program {
102 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
103 + where
104 + S: Serializer,
105 + {
106 + let mut state = serializer.serialize_map(None)?;
107 + state.serialize_entry("type", "Program")?;
108 + state.serialize_entry("body", &self.body)?;
109 + state.serialize_entry("sourceType", &self.source_type)?;
110 + state.serialize_entry("loc", &self.loc)?;
111 + state.serialize_entry("range", &self.range)?;
112 + state.end()
113 + }
114 +}
115 +#[derive(Deserialize, Clone, Debug)]
116 pub struct ExpressionStatement {
117 pub expression: Expression,
118 #[serde(default)]
@@ -79,7 +122,21 @@ pub struct ExpressionStatement {
122 #[serde(default)]
123 pub range: Option<SourceRange>,
124 }
82 -#[derive(Serialize, Deserialize, Clone, Debug)]
125 +impl Serialize for ExpressionStatement {
126 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
127 + where
128 + S: Serializer,
129 + {
130 + let mut state = serializer.serialize_map(None)?;
131 + state.serialize_entry("type", "ExpressionStatement")?;
132 + state.serialize_entry("expression", &self.expression)?;
133 + state.serialize_entry("directive", &self.directive)?;
134 + state.serialize_entry("loc", &self.loc)?;
135 + state.serialize_entry("range", &self.range)?;
136 + state.end()
137 + }
138 +}
139 +#[derive(Deserialize, Clone, Debug)]
140 pub struct BlockStatement {
141 pub body: Vec<Statement>,
142 #[serde(default)]
@@ -87,21 +144,58 @@ pub struct BlockStatement {
144 #[serde(default)]
145 pub range: Option<SourceRange>,
146 }
90 -#[derive(Serialize, Deserialize, Clone, Debug)]
147 +impl Serialize for BlockStatement {
148 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
149 + where
150 + S: Serializer,
151 + {
152 + let mut state = serializer.serialize_map(None)?;
153 + state.serialize_entry("type", "BlockStatement")?;
154 + state.serialize_entry("body", &self.body)?;
155 + state.serialize_entry("loc", &self.loc)?;
156 + state.serialize_entry("range", &self.range)?;
157 + state.end()
158 + }
159 +}
160 +#[derive(Deserialize, Clone, Debug)]
161 pub struct EmptyStatement {
162 #[serde(default)]
163 pub loc: Option<SourceLocation>,
164 #[serde(default)]
165 pub range: Option<SourceRange>,
166 }
97 -#[derive(Serialize, Deserialize, Clone, Debug)]
167 +impl Serialize for EmptyStatement {
168 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
169 + where
170 + S: Serializer,
171 + {
172 + let mut state = serializer.serialize_map(None)?;
173 + state.serialize_entry("type", "EmptyStatement")?;
174 + state.serialize_entry("loc", &self.loc)?;
175 + state.serialize_entry("range", &self.range)?;
176 + state.end()
177 + }
178 +}
179 +#[derive(Deserialize, Clone, Debug)]
180 pub struct DebuggerStatement {
181 #[serde(default)]
182 pub loc: Option<SourceLocation>,
183 #[serde(default)]
184 pub range: Option<SourceRange>,
185 }
104 -#[derive(Serialize, Deserialize, Clone, Debug)]
186 +impl Serialize for DebuggerStatement {
187 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
188 + where
189 + S: Serializer,
190 + {
191 + let mut state = serializer.serialize_map(None)?;
192 + state.serialize_entry("type", "DebuggerStatement")?;
193 + state.serialize_entry("loc", &self.loc)?;
194 + state.serialize_entry("range", &self.range)?;
195 + state.end()
196 + }
197 +}
198 +#[derive(Deserialize, Clone, Debug)]
199 pub struct WithStatement {
200 pub object: Expression,
201 pub body: Statement,
@@ -110,7 +204,21 @@ pub struct WithStatement {
204 #[serde(default)]
205 pub range: Option<SourceRange>,
206 }
113 -#[derive(Serialize, Deserialize, Clone, Debug)]
207 +impl Serialize for WithStatement {
208 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
209 + where
210 + S: Serializer,
211 + {
212 + let mut state = serializer.serialize_map(None)?;
213 + state.serialize_entry("type", "WithStatement")?;
214 + state.serialize_entry("object", &self.object)?;
215 + state.serialize_entry("body", &self.body)?;
216 + state.serialize_entry("loc", &self.loc)?;
217 + state.serialize_entry("range", &self.range)?;
218 + state.end()
219 + }
220 +}
221 +#[derive(Deserialize, Clone, Debug)]
222 pub struct ReturnStatement {
223 pub argument: Option<Expression>,
224 #[serde(default)]
@@ -118,7 +226,20 @@ pub struct ReturnStatement {
226 #[serde(default)]
227 pub range: Option<SourceRange>,
228 }
121 -#[derive(Serialize, Deserialize, Clone, Debug)]
229 +impl Serialize for ReturnStatement {
230 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
231 + where
232 + S: Serializer,
233 + {
234 + let mut state = serializer.serialize_map(None)?;
235 + state.serialize_entry("type", "ReturnStatement")?;
236 + state.serialize_entry("argument", &self.argument)?;
237 + state.serialize_entry("loc", &self.loc)?;
238 + state.serialize_entry("range", &self.range)?;
239 + state.end()
240 + }
241 +}
242 +#[derive(Deserialize, Clone, Debug)]
243 pub struct LabeledStatement {
244 pub label: Identifier,
245 pub body: Statement,
@@ -127,7 +248,21 @@ pub struct LabeledStatement {
248 #[serde(default)]
249 pub range: Option<SourceRange>,
250 }
130 -#[derive(Serialize, Deserialize, Clone, Debug)]
251 +impl Serialize for LabeledStatement {
252 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
253 + where
254 + S: Serializer,
255 + {
256 + let mut state = serializer.serialize_map(None)?;
257 + state.serialize_entry("type", "LabeledStatement")?;
258 + state.serialize_entry("label", &self.label)?;
259 + state.serialize_entry("body", &self.body)?;
260 + state.serialize_entry("loc", &self.loc)?;
261 + state.serialize_entry("range", &self.range)?;
262 + state.end()
263 + }
264 +}
265 +#[derive(Deserialize, Clone, Debug)]
266 pub struct BreakStatement {
267 pub label: Option<Identifier>,
268 #[serde(default)]
@@ -135,7 +270,20 @@ pub struct BreakStatement {
270 #[serde(default)]
271 pub range: Option<SourceRange>,
272 }
138 -#[derive(Serialize, Deserialize, Clone, Debug)]
273 +impl Serialize for BreakStatement {
274 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
275 + where
276 + S: Serializer,
277 + {
278 + let mut state = serializer.serialize_map(None)?;
279 + state.serialize_entry("type", "BreakStatement")?;
280 + state.serialize_entry("label", &self.label)?;
281 + state.serialize_entry("loc", &self.loc)?;
282 + state.serialize_entry("range", &self.range)?;
283 + state.end()
284 + }
285 +}
286 +#[derive(Deserialize, Clone, Debug)]
287 pub struct ContinueStatement {
288 pub label: Option<Identifier>,
289 #[serde(default)]
@@ -143,7 +291,20 @@ pub struct ContinueStatement {
291 #[serde(default)]
292 pub range: Option<SourceRange>,
293 }
146 -#[derive(Serialize, Deserialize, Clone, Debug)]
294 +impl Serialize for ContinueStatement {
295 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
296 + where
297 + S: Serializer,
298 + {
299 + let mut state = serializer.serialize_map(None)?;
300 + state.serialize_entry("type", "ContinueStatement")?;
301 + state.serialize_entry("label", &self.label)?;
302 + state.serialize_entry("loc", &self.loc)?;
303 + state.serialize_entry("range", &self.range)?;
304 + state.end()
305 + }
306 +}
307 +#[derive(Deserialize, Clone, Debug)]
308 pub struct IfStatement {
309 pub test: Expression,
310 pub consequent: Statement,
@@ -153,7 +314,22 @@ pub struct IfStatement {
314 #[serde(default)]
315 pub range: Option<SourceRange>,
316 }
156 -#[derive(Serialize, Deserialize, Clone, Debug)]
317 +impl Serialize for IfStatement {
318 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
319 + where
320 + S: Serializer,
321 + {
322 + let mut state = serializer.serialize_map(None)?;
323 + state.serialize_entry("type", "IfStatement")?;
324 + state.serialize_entry("test", &self.test)?;
325 + state.serialize_entry("consequent", &self.consequent)?;
326 + state.serialize_entry("alternate", &self.alternate)?;
327 + state.serialize_entry("loc", &self.loc)?;
328 + state.serialize_entry("range", &self.range)?;
329 + state.end()
330 + }
331 +}
332 +#[derive(Deserialize, Clone, Debug)]
333 pub struct SwitchStatement {
334 pub discriminant: Expression,
335 pub cases: Vec<SwitchCase>,
@@ -162,7 +338,21 @@ pub struct SwitchStatement {
338 #[serde(default)]
339 pub range: Option<SourceRange>,
340 }
165 -#[derive(Serialize, Deserialize, Clone, Debug)]
341 +impl Serialize for SwitchStatement {
342 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
343 + where
344 + S: Serializer,
345 + {
346 + let mut state = serializer.serialize_map(None)?;
347 + state.serialize_entry("type", "SwitchStatement")?;
348 + state.serialize_entry("discriminant", &self.discriminant)?;
349 + state.serialize_entry("cases", &self.cases)?;
350 + state.serialize_entry("loc", &self.loc)?;
351 + state.serialize_entry("range", &self.range)?;
352 + state.end()
353 + }
354 +}
355 +#[derive(Deserialize, Clone, Debug)]
356 pub struct SwitchCase {
357 pub test: Option<Expression>,
358 pub consequent: Vec<Statement>,
@@ -171,7 +361,21 @@ pub struct SwitchCase {
361 #[serde(default)]
362 pub range: Option<SourceRange>,
363 }
174 -#[derive(Serialize, Deserialize, Clone, Debug)]
364 +impl Serialize for SwitchCase {
365 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
366 + where
367 + S: Serializer,
368 + {
369 + let mut state = serializer.serialize_map(None)?;
370 + state.serialize_entry("type", "SwitchCase")?;
371 + state.serialize_entry("test", &self.test)?;
372 + state.serialize_entry("consequent", &self.consequent)?;
373 + state.serialize_entry("loc", &self.loc)?;
374 + state.serialize_entry("range", &self.range)?;
375 + state.end()
376 + }
377 +}
378 +#[derive(Deserialize, Clone, Debug)]
379 pub struct ThrowStatement {
380 pub argument: Expression,
381 #[serde(default)]
@@ -179,7 +383,20 @@ pub struct ThrowStatement {
383 #[serde(default)]
384 pub range: Option<SourceRange>,
385 }
182 -#[derive(Serialize, Deserialize, Clone, Debug)]
386 +impl Serialize for ThrowStatement {
387 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
388 + where
389 + S: Serializer,
390 + {
391 + let mut state = serializer.serialize_map(None)?;
392 + state.serialize_entry("type", "ThrowStatement")?;
393 + state.serialize_entry("argument", &self.argument)?;
394 + state.serialize_entry("loc", &self.loc)?;
395 + state.serialize_entry("range", &self.range)?;
396 + state.end()
397 + }
398 +}
399 +#[derive(Deserialize, Clone, Debug)]
400 pub struct TryStatement {
401 pub block: BlockStatement,
402 pub handler: Option<CatchClause>,
@@ -189,7 +406,22 @@ pub struct TryStatement {
406 #[serde(default)]
407 pub range: Option<SourceRange>,
408 }
192 -#[derive(Serialize, Deserialize, Clone, Debug)]
409 +impl Serialize for TryStatement {
410 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
411 + where
412 + S: Serializer,
413 + {
414 + let mut state = serializer.serialize_map(None)?;
415 + state.serialize_entry("type", "TryStatement")?;
416 + state.serialize_entry("block", &self.block)?;
417 + state.serialize_entry("handler", &self.handler)?;
418 + state.serialize_entry("finalizer", &self.finalizer)?;
419 + state.serialize_entry("loc", &self.loc)?;
420 + state.serialize_entry("range", &self.range)?;
421 + state.end()
422 + }
423 +}
424 +#[derive(Deserialize, Clone, Debug)]
425 pub struct CatchClause {
426 pub param: Pattern,
427 pub body: BlockStatement,
@@ -198,7 +430,21 @@ pub struct CatchClause {
430 #[serde(default)]
431 pub range: Option<SourceRange>,
432 }
201 -#[derive(Serialize, Deserialize, Clone, Debug)]
433 +impl Serialize for CatchClause {
434 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
435 + where
436 + S: Serializer,
437 + {
438 + let mut state = serializer.serialize_map(None)?;
439 + state.serialize_entry("type", "CatchClause")?;
440 + state.serialize_entry("param", &self.param)?;
441 + state.serialize_entry("body", &self.body)?;
442 + state.serialize_entry("loc", &self.loc)?;
443 + state.serialize_entry("range", &self.range)?;
444 + state.end()
445 + }
446 +}
447 +#[derive(Deserialize, Clone, Debug)]
448 pub struct WhileStatement {
449 pub test: Expression,
450 pub body: Statement,
@@ -207,7 +453,21 @@ pub struct WhileStatement {
453 #[serde(default)]
454 pub range: Option<SourceRange>,
455 }
210 -#[derive(Serialize, Deserialize, Clone, Debug)]
456 +impl Serialize for WhileStatement {
457 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
458 + where
459 + S: Serializer,
460 + {
461 + let mut state = serializer.serialize_map(None)?;
462 + state.serialize_entry("type", "WhileStatement")?;
463 + state.serialize_entry("test", &self.test)?;
464 + state.serialize_entry("body", &self.body)?;
465 + state.serialize_entry("loc", &self.loc)?;
466 + state.serialize_entry("range", &self.range)?;
467 + state.end()
468 + }
469 +}
470 +#[derive(Deserialize, Clone, Debug)]
471 pub struct DoWhileStatement {
472 pub body: Statement,
473 pub test: Expression,
@@ -216,7 +476,21 @@ pub struct DoWhileStatement {
476 #[serde(default)]
477 pub range: Option<SourceRange>,
478 }
219 -#[derive(Serialize, Deserialize, Clone, Debug)]
479 +impl Serialize for DoWhileStatement {
480 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
481 + where
482 + S: Serializer,
483 + {
484 + let mut state = serializer.serialize_map(None)?;
485 + state.serialize_entry("type", "DoWhileStatement")?;
486 + state.serialize_entry("body", &self.body)?;
487 + state.serialize_entry("test", &self.test)?;
488 + state.serialize_entry("loc", &self.loc)?;
489 + state.serialize_entry("range", &self.range)?;
490 + state.end()
491 + }
492 +}
493 +#[derive(Deserialize, Clone, Debug)]
494 pub struct ForStatement {
495 pub init: Option<ForInit>,
496 pub test: Option<Expression>,
@@ -227,7 +501,23 @@ pub struct ForStatement {
501 #[serde(default)]
502 pub range: Option<SourceRange>,
503 }
230 -#[derive(Serialize, Deserialize, Clone, Debug)]
504 +impl Serialize for ForStatement {
505 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
506 + where
507 + S: Serializer,
508 + {
509 + let mut state = serializer.serialize_map(None)?;
510 + state.serialize_entry("type", "ForStatement")?;
511 + state.serialize_entry("init", &self.init)?;
512 + state.serialize_entry("test", &self.test)?;
513 + state.serialize_entry("update", &self.update)?;
514 + state.serialize_entry("body", &self.body)?;
515 + state.serialize_entry("loc", &self.loc)?;
516 + state.serialize_entry("range", &self.range)?;
517 + state.end()
518 + }
519 +}
520 +#[derive(Deserialize, Clone, Debug)]
521 pub struct ForInStatement {
522 pub left: ForInInit,
523 pub right: Expression,
@@ -237,7 +527,22 @@ pub struct ForInStatement {
527 #[serde(default)]
528 pub range: Option<SourceRange>,
529 }
240 -#[derive(Serialize, Deserialize, Clone, Debug)]
530 +impl Serialize for ForInStatement {
531 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
532 + where
533 + S: Serializer,
534 + {
535 + let mut state = serializer.serialize_map(None)?;
536 + state.serialize_entry("type", "ForInStatement")?;
537 + state.serialize_entry("left", &self.left)?;
538 + state.serialize_entry("right", &self.right)?;
539 + state.serialize_entry("body", &self.body)?;
540 + state.serialize_entry("loc", &self.loc)?;
541 + state.serialize_entry("range", &self.range)?;
542 + state.end()
543 + }
544 +}
545 +#[derive(Deserialize, Clone, Debug)]
546 pub struct ForOfStatement {
547 pub left: ForInInit,
548 pub right: Expression,
@@ -247,7 +552,22 @@ pub struct ForOfStatement {
552 #[serde(default)]
553 pub range: Option<SourceRange>,
554 }
250 -#[derive(Serialize, Deserialize, Clone, Debug)]
555 +impl Serialize for ForOfStatement {
556 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
557 + where
558 + S: Serializer,
559 + {
560 + let mut state = serializer.serialize_map(None)?;
561 + state.serialize_entry("type", "ForOfStatement")?;
562 + state.serialize_entry("left", &self.left)?;
563 + state.serialize_entry("right", &self.right)?;
564 + state.serialize_entry("body", &self.body)?;
565 + state.serialize_entry("loc", &self.loc)?;
566 + state.serialize_entry("range", &self.range)?;
567 + state.end()
568 + }
569 +}
570 +#[derive(Deserialize, Clone, Debug)]
571 pub struct FunctionDeclaration {
572 #[serde(flatten)]
573 pub function: Function,
@@ -256,7 +576,23 @@ pub struct FunctionDeclaration {
576 #[serde(default)]
577 pub range: Option<SourceRange>,
578 }
259 -#[derive(Serialize, Deserialize, Clone, Debug)]
579 +impl Serialize for FunctionDeclaration {
580 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
581 + where
582 + S: Serializer,
583 + {
584 + let mut state = serializer.serialize_map(None)?;
585 + state.serialize_entry("type", "FunctionDeclaration")?;
586 + Serialize::serialize(
587 + &self.function,
588 + serde::__private::ser::FlatMapSerializer(&mut state),
589 + )?;
590 + state.serialize_entry("loc", &self.loc)?;
591 + state.serialize_entry("range", &self.range)?;
592 + state.end()
593 + }
594 +}
595 +#[derive(Deserialize, Clone, Debug)]
596 pub struct Class {
597 pub id: Option<Identifier>,
598 #[serde(rename = "superClass")]
@@ -267,7 +603,22 @@ pub struct Class {
603 #[serde(default)]
604 pub range: Option<SourceRange>,
605 }
270 -#[derive(Serialize, Deserialize, Clone, Debug)]
606 +impl Serialize for Class {
607 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
608 + where
609 + S: Serializer,
610 + {
611 + let mut state = serializer.serialize_map(None)?;
612 + state.serialize_entry("type", "Class")?;
613 + state.serialize_entry("id", &self.id)?;
614 + state.serialize_entry("superClass", &self.super_class)?;
615 + state.serialize_entry("body", &self.body)?;
616 + state.serialize_entry("loc", &self.loc)?;
617 + state.serialize_entry("range", &self.range)?;
618 + state.end()
619 + }
620 +}
621 +#[derive(Deserialize, Clone, Debug)]
622 pub struct ClassDeclaration {
623 #[serde(flatten)]
624 pub class: Class,
@@ -276,7 +627,23 @@ pub struct ClassDeclaration {
627 #[serde(default)]
628 pub range: Option<SourceRange>,
629 }
279 -#[derive(Serialize, Deserialize, Clone, Debug)]
630 +impl Serialize for ClassDeclaration {
631 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
632 + where
633 + S: Serializer,
634 + {
635 + let mut state = serializer.serialize_map(None)?;
636 + state.serialize_entry("type", "ClassDeclaration")?;
637 + Serialize::serialize(
638 + &self.class,
639 + serde::__private::ser::FlatMapSerializer(&mut state),
640 + )?;
641 + state.serialize_entry("loc", &self.loc)?;
642 + state.serialize_entry("range", &self.range)?;
643 + state.end()
644 + }
645 +}
646 +#[derive(Deserialize, Clone, Debug)]
647 pub struct ClassExpression {
648 #[serde(flatten)]
649 pub class: Class,
@@ -285,7 +652,23 @@ pub struct ClassExpression {
652 #[serde(default)]
653 pub range: Option<SourceRange>,
654 }
288 -#[derive(Serialize, Deserialize, Clone, Debug)]
655 +impl Serialize for ClassExpression {
656 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
657 + where
658 + S: Serializer,
659 + {
660 + let mut state = serializer.serialize_map(None)?;
661 + state.serialize_entry("type", "ClassExpression")?;
662 + Serialize::serialize(
663 + &self.class,
664 + serde::__private::ser::FlatMapSerializer(&mut state),
665 + )?;
666 + state.serialize_entry("loc", &self.loc)?;
667 + state.serialize_entry("range", &self.range)?;
668 + state.end()
669 + }
670 +}
671 +#[derive(Deserialize, Clone, Debug)]
672 pub struct ClassBody {
673 pub body: Vec<MethodDefinition>,
674 #[serde(default)]
@@ -293,7 +676,20 @@ pub struct ClassBody {
676 #[serde(default)]
677 pub range: Option<SourceRange>,
678 }
296 -#[derive(Serialize, Deserialize, Clone, Debug)]
679 +impl Serialize for ClassBody {
680 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
681 + where
682 + S: Serializer,
683 + {
684 + let mut state = serializer.serialize_map(None)?;
685 + state.serialize_entry("type", "ClassBody")?;
686 + state.serialize_entry("body", &self.body)?;
687 + state.serialize_entry("loc", &self.loc)?;
688 + state.serialize_entry("range", &self.range)?;
689 + state.end()
690 + }
691 +}
692 +#[derive(Deserialize, Clone, Debug)]
693 pub struct MethodDefinition {
694 pub key: Expression,
695 pub value: FunctionExpression,
@@ -307,7 +703,24 @@ pub struct MethodDefinition {
703 #[serde(default)]
704 pub range: Option<SourceRange>,
705 }
310 -#[derive(Serialize, Deserialize, Clone, Debug)]
706 +impl Serialize for MethodDefinition {
707 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
708 + where
709 + S: Serializer,
710 + {
711 + let mut state = serializer.serialize_map(None)?;
712 + state.serialize_entry("type", "MethodDefinition")?;
713 + state.serialize_entry("key", &self.key)?;
714 + state.serialize_entry("value", &self.value)?;
715 + state.serialize_entry("kind", &self.kind)?;
716 + state.serialize_entry("computed", &self.is_computed)?;
717 + state.serialize_entry("static", &self.is_static)?;
718 + state.serialize_entry("loc", &self.loc)?;
719 + state.serialize_entry("range", &self.range)?;
720 + state.end()
721 + }
722 +}
723 +#[derive(Deserialize, Clone, Debug)]
724 pub struct VariableDeclaration {
725 pub kind: VariableDeclarationKind,
726 pub declarations: Vec<VariableDeclarator>,
@@ -316,7 +729,21 @@ pub struct VariableDeclaration {
729 #[serde(default)]
730 pub range: Option<SourceRange>,
731 }
319 -#[derive(Serialize, Deserialize, Clone, Debug)]
732 +impl Serialize for VariableDeclaration {
733 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
734 + where
735 + S: Serializer,
736 + {
737 + let mut state = serializer.serialize_map(None)?;
738 + state.serialize_entry("type", "VariableDeclaration")?;
739 + state.serialize_entry("kind", &self.kind)?;
740 + state.serialize_entry("declarations", &self.declarations)?;
741 + state.serialize_entry("loc", &self.loc)?;
742 + state.serialize_entry("range", &self.range)?;
743 + state.end()
744 + }
745 +}
746 +#[derive(Deserialize, Clone, Debug)]
747 pub struct VariableDeclarator {
748 pub id: Pattern,
749 pub init: Option<Expression>,
@@ -325,14 +752,40 @@ pub struct VariableDeclarator {
752 #[serde(default)]
753 pub range: Option<SourceRange>,
754 }
328 -#[derive(Serialize, Deserialize, Clone, Debug)]
755 +impl Serialize for VariableDeclarator {
756 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
757 + where
758 + S: Serializer,
759 + {
760 + let mut state = serializer.serialize_map(None)?;
761 + state.serialize_entry("type", "VariableDeclarator")?;
762 + state.serialize_entry("id", &self.id)?;
763 + state.serialize_entry("init", &self.init)?;
764 + state.serialize_entry("loc", &self.loc)?;
765 + state.serialize_entry("range", &self.range)?;
766 + state.end()
767 + }
768 +}
769 +#[derive(Deserialize, Clone, Debug)]
770 pub struct ThisExpression {
771 #[serde(default)]
772 pub loc: Option<SourceLocation>,
773 #[serde(default)]
774 pub range: Option<SourceRange>,
775 }
335 -#[derive(Serialize, Deserialize, Clone, Debug)]
776 +impl Serialize for ThisExpression {
777 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
778 + where
779 + S: Serializer,
780 + {
781 + let mut state = serializer.serialize_map(None)?;
782 + state.serialize_entry("type", "ThisExpression")?;
783 + state.serialize_entry("loc", &self.loc)?;
784 + state.serialize_entry("range", &self.range)?;
785 + state.end()
786 + }
787 +}
788 +#[derive(Deserialize, Clone, Debug)]
789 pub struct ArrayExpression {
790 pub elements: Vec<Option<ExpressionOrSpread>>,
791 #[serde(default)]
@@ -340,7 +793,20 @@ pub struct ArrayExpression {
793 #[serde(default)]
794 pub range: Option<SourceRange>,
795 }
343 -#[derive(Serialize, Deserialize, Clone, Debug)]
796 +impl Serialize for ArrayExpression {
797 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
798 + where
799 + S: Serializer,
800 + {
801 + let mut state = serializer.serialize_map(None)?;
802 + state.serialize_entry("type", "ArrayExpression")?;
803 + state.serialize_entry("elements", &self.elements)?;
804 + state.serialize_entry("loc", &self.loc)?;
805 + state.serialize_entry("range", &self.range)?;
806 + state.end()
807 + }
808 +}
809 +#[derive(Deserialize, Clone, Debug)]
810 pub struct ObjectExpression {
811 pub properties: Vec<Property>,
812 #[serde(default)]
@@ -348,7 +814,20 @@ pub struct ObjectExpression {
814 #[serde(default)]
815 pub range: Option<SourceRange>,
816 }
351 -#[derive(Serialize, Deserialize, Clone, Debug)]
817 +impl Serialize for ObjectExpression {
818 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
819 + where
820 + S: Serializer,
821 + {
822 + let mut state = serializer.serialize_map(None)?;
823 + state.serialize_entry("type", "ObjectExpression")?;
824 + state.serialize_entry("properties", &self.properties)?;
825 + state.serialize_entry("loc", &self.loc)?;
826 + state.serialize_entry("range", &self.range)?;
827 + state.end()
828 + }
829 +}
830 +#[derive(Deserialize, Clone, Debug)]
831 pub struct Property {
832 pub key: Expression,
833 pub value: Expression,
@@ -364,7 +843,25 @@ pub struct Property {
843 #[serde(default)]
844 pub range: Option<SourceRange>,
845 }
367 -#[derive(Serialize, Deserialize, Clone, Debug)]
846 +impl Serialize for Property {
847 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
848 + where
849 + S: Serializer,
850 + {
851 + let mut state = serializer.serialize_map(None)?;
852 + state.serialize_entry("type", "Property")?;
853 + state.serialize_entry("key", &self.key)?;
854 + state.serialize_entry("value", &self.value)?;
855 + state.serialize_entry("kind", &self.kind)?;
856 + state.serialize_entry("method", &self.is_method)?;
857 + state.serialize_entry("shorthand", &self.is_shorthand)?;
858 + state.serialize_entry("computed", &self.is_computed)?;
859 + state.serialize_entry("loc", &self.loc)?;
860 + state.serialize_entry("range", &self.range)?;
861 + state.end()
862 + }
863 +}
864 +#[derive(Deserialize, Clone, Debug)]
865 pub struct FunctionExpression {
866 #[serde(flatten)]
867 pub function: Function,
@@ -373,7 +870,23 @@ pub struct FunctionExpression {
870 #[serde(default)]
871 pub range: Option<SourceRange>,
872 }
376 -#[derive(Serialize, Deserialize, Clone, Debug)]
873 +impl Serialize for FunctionExpression {
874 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
875 + where
876 + S: Serializer,
877 + {
878 + let mut state = serializer.serialize_map(None)?;
879 + state.serialize_entry("type", "FunctionExpression")?;
880 + Serialize::serialize(
881 + &self.function,
882 + serde::__private::ser::FlatMapSerializer(&mut state),
883 + )?;
884 + state.serialize_entry("loc", &self.loc)?;
885 + state.serialize_entry("range", &self.range)?;
886 + state.end()
887 + }
888 +}
889 +#[derive(Deserialize, Clone, Debug)]
890 pub struct ArrowFunctionExpression {
891 #[serde(flatten)]
892 pub function: Function,
@@ -384,7 +897,24 @@ pub struct ArrowFunctionExpression {
897 #[serde(default)]
898 pub range: Option<SourceRange>,
899 }
387 -#[derive(Serialize, Deserialize, Clone, Debug)]
900 +impl Serialize for ArrowFunctionExpression {
901 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
902 + where
903 + S: Serializer,
904 + {
905 + let mut state = serializer.serialize_map(None)?;
906 + state.serialize_entry("type", "ArrowFunctionExpression")?;
907 + Serialize::serialize(
908 + &self.function,
909 + serde::__private::ser::FlatMapSerializer(&mut state),
910 + )?;
911 + state.serialize_entry("expression", &self.is_expression)?;
912 + state.serialize_entry("loc", &self.loc)?;
913 + state.serialize_entry("range", &self.range)?;
914 + state.end()
915 + }
916 +}
917 +#[derive(Deserialize, Clone, Debug)]
918 pub struct UnaryExpression {
919 pub operator: UnaryOperator,
920 pub prefix: bool,
@@ -394,7 +924,22 @@ pub struct UnaryExpression {
924 #[serde(default)]
925 pub range: Option<SourceRange>,
926 }
397 -#[derive(Serialize, Deserialize, Clone, Debug)]
927 +impl Serialize for UnaryExpression {
928 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
929 + where
930 + S: Serializer,
931 + {
932 + let mut state = serializer.serialize_map(None)?;
933 + state.serialize_entry("type", "UnaryExpression")?;
934 + state.serialize_entry("operator", &self.operator)?;
935 + state.serialize_entry("prefix", &self.prefix)?;
936 + state.serialize_entry("argument", &self.argument)?;
937 + state.serialize_entry("loc", &self.loc)?;
938 + state.serialize_entry("range", &self.range)?;
939 + state.end()
940 + }
941 +}
942 +#[derive(Deserialize, Clone, Debug)]
943 pub struct UpdateExpression {
944 pub operator: UpdateOperator,
945 pub argument: Expression,
@@ -404,7 +949,22 @@ pub struct UpdateExpression {
949 #[serde(default)]
950 pub range: Option<SourceRange>,
951 }
407 -#[derive(Serialize, Deserialize, Clone, Debug)]
952 +impl Serialize for UpdateExpression {
953 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
954 + where
955 + S: Serializer,
956 + {
957 + let mut state = serializer.serialize_map(None)?;
958 + state.serialize_entry("type", "UpdateExpression")?;
959 + state.serialize_entry("operator", &self.operator)?;
960 + state.serialize_entry("argument", &self.argument)?;
961 + state.serialize_entry("prefix", &self.prefix)?;
962 + state.serialize_entry("loc", &self.loc)?;
963 + state.serialize_entry("range", &self.range)?;
964 + state.end()
965 + }
966 +}
967 +#[derive(Deserialize, Clone, Debug)]
968 pub struct BinaryExpression {
969 pub left: Expression,
970 pub operator: BinaryOperator,
@@ -414,7 +974,22 @@ pub struct BinaryExpression {
974 #[serde(default)]
975 pub range: Option<SourceRange>,
976 }
417 -#[derive(Serialize, Deserialize, Clone, Debug)]
977 +impl Serialize for BinaryExpression {
978 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
979 + where
980 + S: Serializer,
981 + {
982 + let mut state = serializer.serialize_map(None)?;
983 + state.serialize_entry("type", "BinaryExpression")?;
984 + state.serialize_entry("left", &self.left)?;
985 + state.serialize_entry("operator", &self.operator)?;
986 + state.serialize_entry("right", &self.right)?;
987 + state.serialize_entry("loc", &self.loc)?;
988 + state.serialize_entry("range", &self.range)?;
989 + state.end()
990 + }
991 +}
992 +#[derive(Deserialize, Clone, Debug)]
993 pub struct AssignmentExpression {
994 pub operator: AssignmentOperator,
995 pub left: AssignmentTarget,
@@ -424,7 +999,22 @@ pub struct AssignmentExpression {
999 #[serde(default)]
1000 pub range: Option<SourceRange>,
1001 }
427 -#[derive(Serialize, Deserialize, Clone, Debug)]
1002 +impl Serialize for AssignmentExpression {
1003 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1004 + where
1005 + S: Serializer,
1006 + {
1007 + let mut state = serializer.serialize_map(None)?;
1008 + state.serialize_entry("type", "AssignmentExpression")?;
1009 + state.serialize_entry("operator", &self.operator)?;
1010 + state.serialize_entry("left", &self.left)?;
1011 + state.serialize_entry("right", &self.right)?;
1012 + state.serialize_entry("loc", &self.loc)?;
1013 + state.serialize_entry("range", &self.range)?;
1014 + state.end()
1015 + }
1016 +}
1017 +#[derive(Deserialize, Clone, Debug)]
1018 pub struct LogicalExpression {
1019 pub operator: LogicalOperator,
1020 pub left: Expression,
@@ -434,7 +1024,22 @@ pub struct LogicalExpression {
1024 #[serde(default)]
1025 pub range: Option<SourceRange>,
1026 }
437 -#[derive(Serialize, Deserialize, Clone, Debug)]
1027 +impl Serialize for LogicalExpression {
1028 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1029 + where
1030 + S: Serializer,
1031 + {
1032 + let mut state = serializer.serialize_map(None)?;
1033 + state.serialize_entry("type", "LogicalExpression")?;
1034 + state.serialize_entry("operator", &self.operator)?;
1035 + state.serialize_entry("left", &self.left)?;
1036 + state.serialize_entry("right", &self.right)?;
1037 + state.serialize_entry("loc", &self.loc)?;
1038 + state.serialize_entry("range", &self.range)?;
1039 + state.end()
1040 + }
1041 +}
1042 +#[derive(Deserialize, Clone, Debug)]
1043 pub struct MemberExpression {
1044 pub object: ExpressionOrSuper,
1045 pub property: Expression,
@@ -444,7 +1049,22 @@ pub struct MemberExpression {
1049 #[serde(default)]
1050 pub range: Option<SourceRange>,
1051 }
447 -#[derive(Serialize, Deserialize, Clone, Debug)]
1052 +impl Serialize for MemberExpression {
1053 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1054 + where
1055 + S: Serializer,
1056 + {
1057 + let mut state = serializer.serialize_map(None)?;
1058 + state.serialize_entry("type", "MemberExpression")?;
1059 + state.serialize_entry("object", &self.object)?;
1060 + state.serialize_entry("property", &self.property)?;
1061 + state.serialize_entry("computed", &self.computed)?;
1062 + state.serialize_entry("loc", &self.loc)?;
1063 + state.serialize_entry("range", &self.range)?;
1064 + state.end()
1065 + }
1066 +}
1067 +#[derive(Deserialize, Clone, Debug)]
1068 pub struct ConditionalExpression {
1069 pub test: Expression,
1070 pub alternate: Expression,
@@ -454,7 +1074,22 @@ pub struct ConditionalExpression {
1074 #[serde(default)]
1075 pub range: Option<SourceRange>,
1076 }
457 -#[derive(Serialize, Deserialize, Clone, Debug)]
1077 +impl Serialize for ConditionalExpression {
1078 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1079 + where
1080 + S: Serializer,
1081 + {
1082 + let mut state = serializer.serialize_map(None)?;
1083 + state.serialize_entry("type", "ConditionalExpression")?;
1084 + state.serialize_entry("test", &self.test)?;
1085 + state.serialize_entry("alternate", &self.alternate)?;
1086 + state.serialize_entry("consequent", &self.consequent)?;
1087 + state.serialize_entry("loc", &self.loc)?;
1088 + state.serialize_entry("range", &self.range)?;
1089 + state.end()
1090 + }
1091 +}
1092 +#[derive(Deserialize, Clone, Debug)]
1093 pub struct CallExpression {
1094 pub callee: ExpressionOrSuper,
1095 pub arguments: Vec<ExpressionOrSpread>,
@@ -463,7 +1098,21 @@ pub struct CallExpression {
1098 #[serde(default)]
1099 pub range: Option<SourceRange>,
1100 }
466 -#[derive(Serialize, Deserialize, Clone, Debug)]
1101 +impl Serialize for CallExpression {
1102 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1103 + where
1104 + S: Serializer,
1105 + {
1106 + let mut state = serializer.serialize_map(None)?;
1107 + state.serialize_entry("type", "CallExpression")?;
1108 + state.serialize_entry("callee", &self.callee)?;
1109 + state.serialize_entry("arguments", &self.arguments)?;
1110 + state.serialize_entry("loc", &self.loc)?;
1111 + state.serialize_entry("range", &self.range)?;
1112 + state.end()
1113 + }
1114 +}
1115 +#[derive(Deserialize, Clone, Debug)]
1116 pub struct NewExpression {
1117 pub callee: Expression,
1118 pub arguments: Vec<ExpressionOrSpread>,
@@ -472,7 +1121,21 @@ pub struct NewExpression {
1121 #[serde(default)]
1122 pub range: Option<SourceRange>,
1123 }
475 -#[derive(Serialize, Deserialize, Clone, Debug)]
1124 +impl Serialize for NewExpression {
1125 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1126 + where
1127 + S: Serializer,
1128 + {
1129 + let mut state = serializer.serialize_map(None)?;
1130 + state.serialize_entry("type", "NewExpression")?;
1131 + state.serialize_entry("callee", &self.callee)?;
1132 + state.serialize_entry("arguments", &self.arguments)?;
1133 + state.serialize_entry("loc", &self.loc)?;
1134 + state.serialize_entry("range", &self.range)?;
1135 + state.end()
1136 + }
1137 +}
1138 +#[derive(Deserialize, Clone, Debug)]
1139 pub struct SequenceExpression {
1140 pub expressions: Vec<Expression>,
1141 #[serde(default)]
@@ -480,14 +1143,39 @@ pub struct SequenceExpression {
1143 #[serde(default)]
1144 pub range: Option<SourceRange>,
1145 }
483 -#[derive(Serialize, Deserialize, Clone, Debug)]
1146 +impl Serialize for SequenceExpression {
1147 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1148 + where
1149 + S: Serializer,
1150 + {
1151 + let mut state = serializer.serialize_map(None)?;
1152 + state.serialize_entry("type", "SequenceExpression")?;
1153 + state.serialize_entry("expressions", &self.expressions)?;
1154 + state.serialize_entry("loc", &self.loc)?;
1155 + state.serialize_entry("range", &self.range)?;
1156 + state.end()
1157 + }
1158 +}
1159 +#[derive(Deserialize, Clone, Debug)]
1160 pub struct Super {
1161 #[serde(default)]
1162 pub loc: Option<SourceLocation>,
1163 #[serde(default)]
1164 pub range: Option<SourceRange>,
1165 }
490 -#[derive(Serialize, Deserialize, Clone, Debug)]
1166 +impl Serialize for Super {
1167 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1168 + where
1169 + S: Serializer,
1170 + {
1171 + let mut state = serializer.serialize_map(None)?;
1172 + state.serialize_entry("type", "Super")?;
1173 + state.serialize_entry("loc", &self.loc)?;
1174 + state.serialize_entry("range", &self.range)?;
1175 + state.end()
1176 + }
1177 +}
1178 +#[derive(Deserialize, Clone, Debug)]
1179 pub struct SpreadElement {
1180 pub argument: Expression,
1181 #[serde(default)]
@@ -495,7 +1183,20 @@ pub struct SpreadElement {
1183 #[serde(default)]
1184 pub range: Option<SourceRange>,
1185 }
498 -#[derive(Serialize, Deserialize, Clone, Debug)]
1186 +impl Serialize for SpreadElement {
1187 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1188 + where
1189 + S: Serializer,
1190 + {
1191 + let mut state = serializer.serialize_map(None)?;
1192 + state.serialize_entry("type", "SpreadElement")?;
1193 + state.serialize_entry("argument", &self.argument)?;
1194 + state.serialize_entry("loc", &self.loc)?;
1195 + state.serialize_entry("range", &self.range)?;
1196 + state.end()
1197 + }
1198 +}
1199 +#[derive(Deserialize, Clone, Debug)]
1200 pub struct YieldExpression {
1201 #[serde(default)]
1202 pub argument: Option<Expression>,
@@ -506,7 +1207,21 @@ pub struct YieldExpression {
1207 #[serde(default)]
1208 pub range: Option<SourceRange>,
1209 }
509 -#[derive(Serialize, Deserialize, Clone, Debug)]
1210 +impl Serialize for YieldExpression {
1211 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1212 + where
1213 + S: Serializer,
1214 + {
1215 + let mut state = serializer.serialize_map(None)?;
1216 + state.serialize_entry("type", "YieldExpression")?;
1217 + state.serialize_entry("argument", &self.argument)?;
1218 + state.serialize_entry("delegate", &self.is_delegate)?;
1219 + state.serialize_entry("loc", &self.loc)?;
1220 + state.serialize_entry("range", &self.range)?;
1221 + state.end()
1222 + }
1223 +}
1224 +#[derive(Deserialize, Clone, Debug)]
1225 pub struct ImportDeclaration {
1226 pub specifiers: Vec<ImportDeclarationSpecifier>,
1227 pub source: Literal,
@@ -515,7 +1230,21 @@ pub struct ImportDeclaration {
1230 #[serde(default)]
1231 pub range: Option<SourceRange>,
1232 }
518 -#[derive(Serialize, Deserialize, Clone, Debug)]
1233 +impl Serialize for ImportDeclaration {
1234 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1235 + where
1236 + S: Serializer,
1237 + {
1238 + let mut state = serializer.serialize_map(None)?;
1239 + state.serialize_entry("type", "ImportDeclaration")?;
1240 + state.serialize_entry("specifiers", &self.specifiers)?;
1241 + state.serialize_entry("source", &self.source)?;
1242 + state.serialize_entry("loc", &self.loc)?;
1243 + state.serialize_entry("range", &self.range)?;
1244 + state.end()
1245 + }
1246 +}
1247 +#[derive(Deserialize, Clone, Debug)]
1248 pub struct ImportSpecifier {
1249 pub imported: Identifier,
1250 pub local: Identifier,
@@ -524,7 +1253,21 @@ pub struct ImportSpecifier {
1253 #[serde(default)]
1254 pub range: Option<SourceRange>,
1255 }
527 -#[derive(Serialize, Deserialize, Clone, Debug)]
1256 +impl Serialize for ImportSpecifier {
1257 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1258 + where
1259 + S: Serializer,
1260 + {
1261 + let mut state = serializer.serialize_map(None)?;
1262 + state.serialize_entry("type", "ImportSpecifier")?;
1263 + state.serialize_entry("imported", &self.imported)?;
1264 + state.serialize_entry("local", &self.local)?;
1265 + state.serialize_entry("loc", &self.loc)?;
1266 + state.serialize_entry("range", &self.range)?;
1267 + state.end()
1268 + }
1269 +}
1270 +#[derive(Deserialize, Clone, Debug)]
1271 pub struct ImportDefaultSpecifier {
1272 pub local: Identifier,
1273 #[serde(default)]
@@ -532,7 +1275,20 @@ pub struct ImportDefaultSpecifier {
1275 #[serde(default)]
1276 pub range: Option<SourceRange>,
1277 }
535 -#[derive(Serialize, Deserialize, Clone, Debug)]
1278 +impl Serialize for ImportDefaultSpecifier {
1279 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1280 + where
1281 + S: Serializer,
1282 + {
1283 + let mut state = serializer.serialize_map(None)?;
1284 + state.serialize_entry("type", "ImportDefaultSpecifier")?;
1285 + state.serialize_entry("local", &self.local)?;
1286 + state.serialize_entry("loc", &self.loc)?;
1287 + state.serialize_entry("range", &self.range)?;
1288 + state.end()
1289 + }
1290 +}
1291 +#[derive(Deserialize, Clone, Debug)]
1292 pub struct ImportNamespaceSpecifier {
1293 pub local: Identifier,
1294 #[serde(default)]
@@ -540,7 +1296,20 @@ pub struct ImportNamespaceSpecifier {
1296 #[serde(default)]
1297 pub range: Option<SourceRange>,
1298 }
543 -#[derive(Serialize, Deserialize, Clone, Debug)]
1299 +impl Serialize for ImportNamespaceSpecifier {
1300 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1301 + where
1302 + S: Serializer,
1303 + {
1304 + let mut state = serializer.serialize_map(None)?;
1305 + state.serialize_entry("type", "ImportNamespaceSpecifier")?;
1306 + state.serialize_entry("local", &self.local)?;
1307 + state.serialize_entry("loc", &self.loc)?;
1308 + state.serialize_entry("range", &self.range)?;
1309 + state.end()
1310 + }
1311 +}
1312 +#[derive(Deserialize, Clone, Debug)]
1313 pub struct ExportNamedDeclaration {
1314 pub declaration: Option<Declaration>,
1315 pub specifiers: Vec<ExportSpecifier>,
@@ -550,7 +1319,22 @@ pub struct ExportNamedDeclaration {
1319 #[serde(default)]
1320 pub range: Option<SourceRange>,
1321 }
553 -#[derive(Serialize, Deserialize, Clone, Debug)]
1322 +impl Serialize for ExportNamedDeclaration {
1323 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1324 + where
1325 + S: Serializer,
1326 + {
1327 + let mut state = serializer.serialize_map(None)?;
1328 + state.serialize_entry("type", "ExportNamedDeclaration")?;
1329 + state.serialize_entry("declaration", &self.declaration)?;
1330 + state.serialize_entry("specifiers", &self.specifiers)?;
1331 + state.serialize_entry("source", &self.source)?;
1332 + state.serialize_entry("loc", &self.loc)?;
1333 + state.serialize_entry("range", &self.range)?;
1334 + state.end()
1335 + }
1336 +}
1337 +#[derive(Deserialize, Clone, Debug)]
1338 pub struct ExportSpecifier {
1339 pub exported: Identifier,
1340 #[serde(default)]
@@ -558,7 +1342,20 @@ pub struct ExportSpecifier {
1342 #[serde(default)]
1343 pub range: Option<SourceRange>,
1344 }
561 -#[derive(Serialize, Deserialize, Clone, Debug)]
1345 +impl Serialize for ExportSpecifier {
1346 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1347 + where
1348 + S: Serializer,
1349 + {
1350 + let mut state = serializer.serialize_map(None)?;
1351 + state.serialize_entry("type", "ExportSpecifier")?;
1352 + state.serialize_entry("exported", &self.exported)?;
1353 + state.serialize_entry("loc", &self.loc)?;
1354 + state.serialize_entry("range", &self.range)?;
1355 + state.end()
1356 + }
1357 +}
1358 +#[derive(Deserialize, Clone, Debug)]
1359 pub struct ExportDefaultDeclaration {
1360 pub declaration: Declaration,
1361 #[serde(default)]
@@ -566,7 +1363,20 @@ pub struct ExportDefaultDeclaration {
1363 #[serde(default)]
1364 pub range: Option<SourceRange>,
1365 }
569 -#[derive(Serialize, Deserialize, Clone, Debug)]
1366 +impl Serialize for ExportDefaultDeclaration {
1367 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1368 + where
1369 + S: Serializer,
1370 + {
1371 + let mut state = serializer.serialize_map(None)?;
1372 + state.serialize_entry("type", "ExportDefaultDeclaration")?;
1373 + state.serialize_entry("declaration", &self.declaration)?;
1374 + state.serialize_entry("loc", &self.loc)?;
1375 + state.serialize_entry("range", &self.range)?;
1376 + state.end()
1377 + }
1378 +}
1379 +#[derive(Deserialize, Clone, Debug)]
1380 pub struct ExportAllDeclaration {
1381 pub source: Literal,
1382 #[serde(default)]
@@ -574,7 +1384,20 @@ pub struct ExportAllDeclaration {
1384 #[serde(default)]
1385 pub range: Option<SourceRange>,
1386 }
577 -#[derive(Serialize, Deserialize, Clone, Debug)]
1387 +impl Serialize for ExportAllDeclaration {
1388 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1389 + where
1390 + S: Serializer,
1391 + {
1392 + let mut state = serializer.serialize_map(None)?;
1393 + state.serialize_entry("type", "ExportAllDeclaration")?;
1394 + state.serialize_entry("source", &self.source)?;
1395 + state.serialize_entry("loc", &self.loc)?;
1396 + state.serialize_entry("range", &self.range)?;
1397 + state.end()
1398 + }
1399 +}
1400 +#[derive(Deserialize, Clone, Debug)]
1401 pub struct JSXIdentifier {
1402 pub name: String,
1403 #[serde(default)]
@@ -582,7 +1405,20 @@ pub struct JSXIdentifier {
1405 #[serde(default)]
1406 pub range: Option<SourceRange>,
1407 }
585 -#[derive(Serialize, Deserialize, Clone, Debug)]
1408 +impl Serialize for JSXIdentifier {
1409 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1410 + where
1411 + S: Serializer,
1412 + {
1413 + let mut state = serializer.serialize_map(None)?;
1414 + state.serialize_entry("type", "JSXIdentifier")?;
1415 + state.serialize_entry("name", &self.name)?;
1416 + state.serialize_entry("loc", &self.loc)?;
1417 + state.serialize_entry("range", &self.range)?;
1418 + state.end()
1419 + }
1420 +}
1421 +#[derive(Deserialize, Clone, Debug)]
1422 pub struct JSXNamespacedName {
1423 pub namespace: JSXIdentifier,
1424 pub name: JSXIdentifier,
@@ -591,7 +1427,21 @@ pub struct JSXNamespacedName {
1427 #[serde(default)]
1428 pub range: Option<SourceRange>,
1429 }
594 -#[derive(Serialize, Deserialize, Clone, Debug)]
1430 +impl Serialize for JSXNamespacedName {
1431 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1432 + where
1433 + S: Serializer,
1434 + {
1435 + let mut state = serializer.serialize_map(None)?;
1436 + state.serialize_entry("type", "JSXNamespacedName")?;
1437 + state.serialize_entry("namespace", &self.namespace)?;
1438 + state.serialize_entry("name", &self.name)?;
1439 + state.serialize_entry("loc", &self.loc)?;
1440 + state.serialize_entry("range", &self.range)?;
1441 + state.end()
1442 + }
1443 +}
1444 +#[derive(Deserialize, Clone, Debug)]
1445 pub struct JSXMemberExpression {
1446 pub object: JSXMemberExpressionOrIdentifier,
1447 pub property: JSXIdentifier,
@@ -600,14 +1450,40 @@ pub struct JSXMemberExpression {
1450 #[serde(default)]
1451 pub range: Option<SourceRange>,
1452 }
603 -#[derive(Serialize, Deserialize, Clone, Debug)]
1453 +impl Serialize for JSXMemberExpression {
1454 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1455 + where
1456 + S: Serializer,
1457 + {
1458 + let mut state = serializer.serialize_map(None)?;
1459 + state.serialize_entry("type", "JSXMemberExpression")?;
1460 + state.serialize_entry("object", &self.object)?;
1461 + state.serialize_entry("property", &self.property)?;
1462 + state.serialize_entry("loc", &self.loc)?;
1463 + state.serialize_entry("range", &self.range)?;
1464 + state.end()
1465 + }
1466 +}
1467 +#[derive(Deserialize, Clone, Debug)]
1468 pub struct JSXEmptyExpression {
1469 #[serde(default)]
1470 pub loc: Option<SourceLocation>,
1471 #[serde(default)]
1472 pub range: Option<SourceRange>,
1473 }
610 -#[derive(Serialize, Deserialize, Clone, Debug)]
1474 +impl Serialize for JSXEmptyExpression {
1475 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1476 + where
1477 + S: Serializer,
1478 + {
1479 + let mut state = serializer.serialize_map(None)?;
1480 + state.serialize_entry("type", "JSXEmptyExpression")?;
1481 + state.serialize_entry("loc", &self.loc)?;
1482 + state.serialize_entry("range", &self.range)?;
1483 + state.end()
1484 + }
1485 +}
1486 +#[derive(Deserialize, Clone, Debug)]
1487 pub struct JSXExpressionContainer {
1488 pub expression: JSXExpressionOrEmpty,
1489 #[serde(default)]
@@ -615,7 +1491,20 @@ pub struct JSXExpressionContainer {
1491 #[serde(default)]
1492 pub range: Option<SourceRange>,
1493 }
618 -#[derive(Serialize, Deserialize, Clone, Debug)]
1494 +impl Serialize for JSXExpressionContainer {
1495 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1496 + where
1497 + S: Serializer,
1498 + {
1499 + let mut state = serializer.serialize_map(None)?;
1500 + state.serialize_entry("type", "JSXExpressionContainer")?;
1501 + state.serialize_entry("expression", &self.expression)?;
1502 + state.serialize_entry("loc", &self.loc)?;
1503 + state.serialize_entry("range", &self.range)?;
1504 + state.end()
1505 + }
1506 +}
1507 +#[derive(Deserialize, Clone, Debug)]
1508 pub struct JSXSpreadChild {
1509 pub expression: Expression,
1510 #[serde(default)]
@@ -623,7 +1512,20 @@ pub struct JSXSpreadChild {
1512 #[serde(default)]
1513 pub range: Option<SourceRange>,
1514 }
626 -#[derive(Serialize, Deserialize, Clone, Debug)]
1515 +impl Serialize for JSXSpreadChild {
1516 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1517 + where
1518 + S: Serializer,
1519 + {
1520 + let mut state = serializer.serialize_map(None)?;
1521 + state.serialize_entry("type", "JSXSpreadChild")?;
1522 + state.serialize_entry("expression", &self.expression)?;
1523 + state.serialize_entry("loc", &self.loc)?;
1524 + state.serialize_entry("range", &self.range)?;
1525 + state.end()
1526 + }
1527 +}
1528 +#[derive(Deserialize, Clone, Debug)]
1529 pub struct JSXOpeningElement {
1530 pub name: JSXElementName,
1531 pub attributes: Vec<JSXAttributeOrSpread>,
@@ -634,7 +1536,22 @@ pub struct JSXOpeningElement {
1536 #[serde(default)]
1537 pub range: Option<SourceRange>,
1538 }
637 -#[derive(Serialize, Deserialize, Clone, Debug)]
1539 +impl Serialize for JSXOpeningElement {
1540 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1541 + where
1542 + S: Serializer,
1543 + {
1544 + let mut state = serializer.serialize_map(None)?;
1545 + state.serialize_entry("type", "JSXOpeningElement")?;
1546 + state.serialize_entry("name", &self.name)?;
1547 + state.serialize_entry("attributes", &self.attributes)?;
1548 + state.serialize_entry("selfClosing", &self.self_closing)?;
1549 + state.serialize_entry("loc", &self.loc)?;
1550 + state.serialize_entry("range", &self.range)?;
1551 + state.end()
1552 + }
1553 +}
1554 +#[derive(Deserialize, Clone, Debug)]
1555 pub struct JSXClosingElement {
1556 pub name: JSXElementName,
1557 #[serde(default)]
@@ -642,7 +1559,20 @@ pub struct JSXClosingElement {
1559 #[serde(default)]
1560 pub range: Option<SourceRange>,
1561 }
645 -#[derive(Serialize, Deserialize, Clone, Debug)]
1562 +impl Serialize for JSXClosingElement {
1563 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1564 + where
1565 + S: Serializer,
1566 + {
1567 + let mut state = serializer.serialize_map(None)?;
1568 + state.serialize_entry("type", "JSXClosingElement")?;
1569 + state.serialize_entry("name", &self.name)?;
1570 + state.serialize_entry("loc", &self.loc)?;
1571 + state.serialize_entry("range", &self.range)?;
1572 + state.end()
1573 + }
1574 +}
1575 +#[derive(Deserialize, Clone, Debug)]
1576 pub struct JSXAttribute {
1577 pub name: JSXIdentifierOrNamespacedName,
1578 pub value: Option<JSXAttributeValue>,
@@ -651,7 +1581,21 @@ pub struct JSXAttribute {
1581 #[serde(default)]
1582 pub range: Option<SourceRange>,
1583 }
654 -#[derive(Serialize, Deserialize, Clone, Debug)]
1584 +impl Serialize for JSXAttribute {
1585 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1586 + where
1587 + S: Serializer,
1588 + {
1589 + let mut state = serializer.serialize_map(None)?;
1590 + state.serialize_entry("type", "JSXAttribute")?;
1591 + state.serialize_entry("name", &self.name)?;
1592 + state.serialize_entry("value", &self.value)?;
1593 + state.serialize_entry("loc", &self.loc)?;
1594 + state.serialize_entry("range", &self.range)?;
1595 + state.end()
1596 + }
1597 +}
1598 +#[derive(Deserialize, Clone, Debug)]
1599 pub struct JSXSpreadAttribute {
1600 pub argument: Expression,
1601 #[serde(default)]
@@ -659,7 +1603,20 @@ pub struct JSXSpreadAttribute {
1603 #[serde(default)]
1604 pub range: Option<SourceRange>,
1605 }
662 -#[derive(Serialize, Deserialize, Clone, Debug)]
1606 +impl Serialize for JSXSpreadAttribute {
1607 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1608 + where
1609 + S: Serializer,
1610 + {
1611 + let mut state = serializer.serialize_map(None)?;
1612 + state.serialize_entry("type", "JSXSpreadAttribute")?;
1613 + state.serialize_entry("argument", &self.argument)?;
1614 + state.serialize_entry("loc", &self.loc)?;
1615 + state.serialize_entry("range", &self.range)?;
1616 + state.end()
1617 + }
1618 +}
1619 +#[derive(Deserialize, Clone, Debug)]
1620 pub struct JSXText {
1621 pub value: String,
1622 pub raw: String,
@@ -668,7 +1625,21 @@ pub struct JSXText {
1625 #[serde(default)]
1626 pub range: Option<SourceRange>,
1627 }
671 -#[derive(Serialize, Deserialize, Clone, Debug)]
1628 +impl Serialize for JSXText {
1629 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1630 + where
1631 + S: Serializer,
1632 + {
1633 + let mut state = serializer.serialize_map(None)?;
1634 + state.serialize_entry("type", "JSXText")?;
1635 + state.serialize_entry("value", &self.value)?;
1636 + state.serialize_entry("raw", &self.raw)?;
1637 + state.serialize_entry("loc", &self.loc)?;
1638 + state.serialize_entry("range", &self.range)?;
1639 + state.end()
1640 + }
1641 +}
1642 +#[derive(Deserialize, Clone, Debug)]
1643 pub struct JSXElement {
1644 #[serde(rename = "openingElement")]
1645 pub opening_element: JSXOpeningElement,
@@ -680,7 +1651,22 @@ pub struct JSXElement {
1651 #[serde(default)]
1652 pub range: Option<SourceRange>,
1653 }
683 -#[derive(Serialize, Deserialize, Clone, Debug)]
1654 +impl Serialize for JSXElement {
1655 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1656 + where
1657 + S: Serializer,
1658 + {
1659 + let mut state = serializer.serialize_map(None)?;
1660 + state.serialize_entry("type", "JSXElement")?;
1661 + state.serialize_entry("openingElement", &self.opening_element)?;
1662 + state.serialize_entry("children", &self.children)?;
1663 + state.serialize_entry("closingElement", &self.closing_element)?;
1664 + state.serialize_entry("loc", &self.loc)?;
1665 + state.serialize_entry("range", &self.range)?;
1666 + state.end()
1667 + }
1668 +}
1669 +#[derive(Deserialize, Clone, Debug)]
1670 pub struct JSXFragment {
1671 #[serde(rename = "openingFragment")]
1672 pub opening_fragment: JSXOpeningFragment,
@@ -692,21 +1678,60 @@ pub struct JSXFragment {
1678 #[serde(default)]
1679 pub range: Option<SourceRange>,
1680 }
695 -#[derive(Serialize, Deserialize, Clone, Debug)]
1681 +impl Serialize for JSXFragment {
1682 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1683 + where
1684 + S: Serializer,
1685 + {
1686 + let mut state = serializer.serialize_map(None)?;
1687 + state.serialize_entry("type", "JSXFragment")?;
1688 + state.serialize_entry("openingFragment", &self.opening_fragment)?;
1689 + state.serialize_entry("children", &self.children)?;
1690 + state.serialize_entry("closingFragment", &self.closing_fragment)?;
1691 + state.serialize_entry("loc", &self.loc)?;
1692 + state.serialize_entry("range", &self.range)?;
1693 + state.end()
1694 + }
1695 +}
1696 +#[derive(Deserialize, Clone, Debug)]
1697 pub struct JSXOpeningFragment {
1698 #[serde(default)]
1699 pub loc: Option<SourceLocation>,
1700 #[serde(default)]
1701 pub range: Option<SourceRange>,
1702 }
702 -#[derive(Serialize, Deserialize, Clone, Debug)]
1703 +impl Serialize for JSXOpeningFragment {
1704 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1705 + where
1706 + S: Serializer,
1707 + {
1708 + let mut state = serializer.serialize_map(None)?;
1709 + state.serialize_entry("type", "JSXOpeningFragment")?;
1710 + state.serialize_entry("loc", &self.loc)?;
1711 + state.serialize_entry("range", &self.range)?;
1712 + state.end()
1713 + }
1714 +}
1715 +#[derive(Deserialize, Clone, Debug)]
1716 pub struct JSXClosingFragment {
1717 #[serde(default)]
1718 pub loc: Option<SourceLocation>,
1719 #[serde(default)]
1720 pub range: Option<SourceRange>,
1721 }
709 -#[derive(Serialize, Deserialize, Clone, Debug)]
1722 +impl Serialize for JSXClosingFragment {
1723 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1724 + where
1725 + S: Serializer,
1726 + {
1727 + let mut state = serializer.serialize_map(None)?;
1728 + state.serialize_entry("type", "JSXClosingFragment")?;
1729 + state.serialize_entry("loc", &self.loc)?;
1730 + state.serialize_entry("range", &self.range)?;
1731 + state.end()
1732 + }
1733 +}
1734 +#[derive(Deserialize, Clone, Debug)]
1735 pub struct ArrayPattern {
1736 pub elements: Vec<Option<Pattern>>,
1737 #[serde(default)]
@@ -714,7 +1739,20 @@ pub struct ArrayPattern {
1739 #[serde(default)]
1740 pub range: Option<SourceRange>,
1741 }
717 -#[derive(Serialize, Deserialize, Clone, Debug)]
1742 +impl Serialize for ArrayPattern {
1743 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1744 + where
1745 + S: Serializer,
1746 + {
1747 + let mut state = serializer.serialize_map(None)?;
1748 + state.serialize_entry("type", "ArrayPattern")?;
1749 + state.serialize_entry("elements", &self.elements)?;
1750 + state.serialize_entry("loc", &self.loc)?;
1751 + state.serialize_entry("range", &self.range)?;
1752 + state.end()
1753 + }
1754 +}
1755 +#[derive(Deserialize, Clone, Debug)]
1756 pub struct ObjectPattern {
1757 pub properties: Vec<AssignmentProperty>,
1758 #[serde(default)]
@@ -722,7 +1760,20 @@ pub struct ObjectPattern {
1760 #[serde(default)]
1761 pub range: Option<SourceRange>,
1762 }
725 -#[derive(Serialize, Deserialize, Clone, Debug)]
1763 +impl Serialize for ObjectPattern {
1764 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1765 + where
1766 + S: Serializer,
1767 + {
1768 + let mut state = serializer.serialize_map(None)?;
1769 + state.serialize_entry("type", "ObjectPattern")?;
1770 + state.serialize_entry("properties", &self.properties)?;
1771 + state.serialize_entry("loc", &self.loc)?;
1772 + state.serialize_entry("range", &self.range)?;
1773 + state.end()
1774 + }
1775 +}
1776 +#[derive(Deserialize, Clone, Debug)]
1777 pub struct AssignmentProperty {
1778 pub key: PropertyKey,
1779 pub value: Pattern,
@@ -733,7 +1784,23 @@ pub struct AssignmentProperty {
1784 #[serde(default)]
1785 pub range: Option<SourceRange>,
1786 }
736 -#[derive(Serialize, Deserialize, Clone, Debug)]
1787 +impl Serialize for AssignmentProperty {
1788 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1789 + where
1790 + S: Serializer,
1791 + {
1792 + let mut state = serializer.serialize_map(None)?;
1793 + state.serialize_entry("type", "Property")?;
1794 + state.serialize_entry("key", &self.key)?;
1795 + state.serialize_entry("value", &self.value)?;
1796 + state.serialize_entry("kind", &self.kind)?;
1797 + state.serialize_entry("method", &self.method)?;
1798 + state.serialize_entry("loc", &self.loc)?;
1799 + state.serialize_entry("range", &self.range)?;
1800 + state.end()
1801 + }
1802 +}
1803 +#[derive(Deserialize, Clone, Debug)]
1804 pub struct RestElement {
1805 pub argument: Pattern,
1806 #[serde(default)]
@@ -741,7 +1808,20 @@ pub struct RestElement {
1808 #[serde(default)]
1809 pub range: Option<SourceRange>,
1810 }
744 -#[derive(Serialize, Deserialize, Clone, Debug)]
1811 +impl Serialize for RestElement {
1812 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1813 + where
1814 + S: Serializer,
1815 + {
1816 + let mut state = serializer.serialize_map(None)?;
1817 + state.serialize_entry("type", "RestElement")?;
1818 + state.serialize_entry("argument", &self.argument)?;
1819 + state.serialize_entry("loc", &self.loc)?;
1820 + state.serialize_entry("range", &self.range)?;
1821 + state.end()
1822 + }
1823 +}
1824 +#[derive(Deserialize, Clone, Debug)]
1825 pub struct AssignmentPattern {
1826 pub left: Pattern,
1827 pub right: Expression,
@@ -750,8 +1830,22 @@ pub struct AssignmentPattern {
1830 #[serde(default)]
1831 pub range: Option<SourceRange>,
1832 }
1833 +impl Serialize for AssignmentPattern {
1834 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1835 + where
1836 + S: Serializer,
1837 + {
1838 + let mut state = serializer.serialize_map(None)?;
1839 + state.serialize_entry("type", "AssignmentPattern")?;
1840 + state.serialize_entry("left", &self.left)?;
1841 + state.serialize_entry("right", &self.right)?;
1842 + state.serialize_entry("loc", &self.loc)?;
1843 + state.serialize_entry("range", &self.range)?;
1844 + state.end()
1845 + }
1846 +}
1847 #[derive(Serialize, Clone, Debug)]
754 -#[serde(tag = "type")]
1848 +#[serde(untagged)]
1849 pub enum Statement {
1850 BlockStatement(Box<BlockStatement>),
1851 BreakStatement(Box<BreakStatement>),
@@ -808,7 +1902,7 @@ impl<'de> serde::Deserialize<'de> for Statement {
1902 deserializer,
1903 serde::__private::de::TaggedContentVisitor::<
1904 __StatementTag,
811 - >::new("type", "Pattern"),
1905 + >::new("type", "Statement"),
1906 )?;
1907 match tagged.0 {
1908 __StatementTag::BlockStatement => {
@@ -983,7 +2077,7 @@ impl<'de> serde::Deserialize<'de> for Statement {
2077 }
2078 }
2079 #[derive(Serialize, Clone, Debug)]
986 -#[serde(tag = "type")]
2080 +#[serde(untagged)]
2081 pub enum Expression {
2082 ArrayExpression(Box<ArrayExpression>),
2083 ArrowFunctionExpression(Box<ArrowFunctionExpression>),
@@ -1038,7 +2132,7 @@ impl<'de> serde::Deserialize<'de> for Expression {
2132 deserializer,
2133 serde::__private::de::TaggedContentVisitor::<
2134 __ExpressionTag,
1041 - >::new("type", "Pattern"),
2135 + >::new("type", "Expression"),
2136 )?;
2137 match tagged.0 {
2138 __ExpressionTag::ArrayExpression => {
@@ -1205,7 +2299,7 @@ impl<'de> serde::Deserialize<'de> for Expression {
2299 }
2300 }
2301 #[derive(Serialize, Clone, Debug)]
1208 -#[serde(tag = "type")]
2302 +#[serde(untagged)]
2303 pub enum Declaration {
2304 ClassDeclaration(Box<ClassDeclaration>),
2305 FunctionDeclaration(Box<FunctionDeclaration>),
@@ -1226,7 +2320,7 @@ impl<'de> serde::Deserialize<'de> for Declaration {
2320 deserializer,
2321 serde::__private::de::TaggedContentVisitor::<
2322 __DeclarationTag,
1229 - >::new("type", "Pattern"),
2323 + >::new("type", "Declaration"),
2324 )?;
2325 match tagged.0 {
2326 __DeclarationTag::ClassDeclaration => {
@@ -1257,7 +2351,7 @@ impl<'de> serde::Deserialize<'de> for Declaration {
2351 }
2352 }
2353 #[derive(Serialize, Clone, Debug)]
1260 -#[serde(tag = "type")]
2354 +#[serde(untagged)]
2355 pub enum ImportDeclarationSpecifier {
2356 ImportDefaultSpecifier(Box<ImportDefaultSpecifier>),
2357 ImportNamespaceSpecifier(Box<ImportNamespaceSpecifier>),
@@ -1278,7 +2372,7 @@ impl<'de> serde::Deserialize<'de> for ImportDeclarationSpecifier {
2372 deserializer,
2373 serde::__private::de::TaggedContentVisitor::<
2374 __ImportDeclarationSpecifierTag,
1281 - >::new("type", "Pattern"),
2375 + >::new("type", "ImportDeclarationSpecifier"),
2376 )?;
2377 match tagged.0 {
2378 __ImportDeclarationSpecifierTag::ImportSpecifier => {
@@ -1351,7 +2445,7 @@ impl<'de> serde::Deserialize<'de> for ModuleItem {
2445 deserializer,
2446 serde::__private::de::TaggedContentVisitor::<
2447 __ModuleItemTag,
1354 - >::new("type", "Pattern"),
2448 + >::new("type", "ModuleItem"),
2449 )?;
2450 match tagged.0 {
2451 __ModuleItemTag::ImportDeclaration => {
@@ -1574,7 +2668,7 @@ impl<'de> serde::Deserialize<'de> for ModuleItem {
2668 }
2669 }
2670 #[derive(Serialize, Clone, Debug)]
1577 -#[serde(tag = "type")]
2671 +#[serde(untagged)]
2672 pub enum ImportOrExportDeclaration {
2673 ExportAllDeclaration(Box<ExportAllDeclaration>),
2674 ExportDefaultDeclaration(Box<ExportDefaultDeclaration>),
@@ -1597,7 +2691,7 @@ impl<'de> serde::Deserialize<'de> for ImportOrExportDeclaration {
2691 deserializer,
2692 serde::__private::de::TaggedContentVisitor::<
2693 __ImportOrExportDeclarationTag,
1600 - >::new("type", "Pattern"),
2694 + >::new("type", "ImportOrExportDeclaration"),
2695 )?;
2696 match tagged.0 {
2697 __ImportOrExportDeclarationTag::ImportDeclaration => {
@@ -1674,7 +2768,7 @@ impl<'de> serde::Deserialize<'de> for ExpressionOrSuper {
2768 deserializer,
2769 serde::__private::de::TaggedContentVisitor::<
2770 __ExpressionOrSuperTag,
1677 - >::new("type", "Pattern"),
2771 + >::new("type", "ExpressionOrSuper"),
2772 )?;
2773 match tagged.0 {
2774 __ExpressionOrSuperTag::ArrayExpression => {
@@ -1895,7 +2989,7 @@ impl<'de> serde::Deserialize<'de> for ExpressionOrSpread {
2989 deserializer,
2990 serde::__private::de::TaggedContentVisitor::<
2991 __ExpressionOrSpreadTag,
1898 - >::new("type", "Pattern"),
2992 + >::new("type", "ExpressionOrSpread"),
2993 )?;
2994 match tagged.0 {
2995 __ExpressionOrSpreadTag::ArrayExpression => {
@@ -2120,7 +3214,7 @@ impl<'de> serde::Deserialize<'de> for FunctionBody {
3214 deserializer,
3215 serde::__private::de::TaggedContentVisitor::<
3216 __FunctionBodyTag,
2123 - >::new("type", "Pattern"),
3217 + >::new("type", "FunctionBody"),
3218 )?;
3219 match tagged.0 {
3220 __FunctionBodyTag::BlockStatement => {
@@ -2295,7 +3389,7 @@ impl<'de> serde::Deserialize<'de> for FunctionBody {
3389 }
3390 }
3391 #[derive(Serialize, Clone, Debug)]
2298 -#[serde(tag = "type")]
3392 +#[serde(untagged)]
3393 pub enum Pattern {
3394 ArrayPattern(Box<ArrayPattern>),
3395 AssignmentPattern(Box<AssignmentPattern>),
@@ -2405,7 +3499,7 @@ impl<'de> serde::Deserialize<'de> for ForInit {
3499 deserializer,
3500 serde::__private::de::TaggedContentVisitor::<
3501 __ForInitTag,
2408 - >::new("type", "Pattern"),
3502 + >::new("type", "ForInit"),
3503 )?;
3504 match tagged.0 {
3505 __ForInitTag::ArrayExpression => {
@@ -2603,7 +3697,7 @@ impl<'de> serde::Deserialize<'de> for ForInInit {
3697 deserializer,
3698 serde::__private::de::TaggedContentVisitor::<
3699 __ForInInitTag,
2606 - >::new("type", "Pattern"),
3700 + >::new("type", "ForInInit"),
3701 )?;
3702 match tagged.0 {
3703 __ForInInitTag::Identifier => {
@@ -2658,7 +3752,7 @@ impl<'de> serde::Deserialize<'de> for ForInInit {
3752 }
3753 }
3754 #[derive(Serialize, Clone, Debug)]
2661 -#[serde(tag = "type")]
3755 +#[serde(untagged)]
3756 pub enum PropertyKey {
3757 Identifier(Box<Identifier>),
3758 Literal(Box<Literal>),
@@ -2677,7 +3771,7 @@ impl<'de> serde::Deserialize<'de> for PropertyKey {
3771 deserializer,
3772 serde::__private::de::TaggedContentVisitor::<
3773 __PropertyKeyTag,
2680 - >::new("type", "Pattern"),
3774 + >::new("type", "PropertyKey"),
3775 )?;
3776 match tagged.0 {
3777 __PropertyKeyTag::Identifier => {
@@ -2741,7 +3835,7 @@ impl<'de> serde::Deserialize<'de> for AssignmentTarget {
3835 deserializer,
3836 serde::__private::de::TaggedContentVisitor::<
3837 __AssignmentTargetTag,
2744 - >::new("type", "Pattern"),
3838 + >::new("type", "AssignmentTarget"),
3839 )?;
3840 match tagged.0 {
3841 __AssignmentTargetTag::ArrayExpression => {
@@ -2944,7 +4038,7 @@ impl<'de> serde::Deserialize<'de> for AssignmentTarget {
4038 }
4039 }
4040 #[derive(Serialize, Clone, Debug)]
2947 -#[serde(tag = "type")]
4041 +#[serde(untagged)]
4042 pub enum JSXMemberExpressionOrIdentifier {
4043 JSXIdentifier(Box<JSXIdentifier>),
4044 JSXMemberExpression(Box<JSXMemberExpression>),
@@ -2963,7 +4057,7 @@ impl<'de> serde::Deserialize<'de> for JSXMemberExpressionOrIdentifier {
4057 deserializer,
4058 serde::__private::de::TaggedContentVisitor::<
4059 __JSXMemberExpressionOrIdentifierTag,
2966 - >::new("type", "Pattern"),
4060 + >::new("type", "JSXMemberExpressionOrIdentifier"),
4061 )?;
4062 match tagged.0 {
4063 __JSXMemberExpressionOrIdentifierTag::JSXMemberExpression => {
@@ -3024,7 +4118,7 @@ impl<'de> serde::Deserialize<'de> for JSXExpressionOrEmpty {
4118 deserializer,
4119 serde::__private::de::TaggedContentVisitor::<
4120 __JSXExpressionOrEmptyTag,
3027 - >::new("type", "Pattern"),
4121 + >::new("type", "JSXExpressionOrEmpty"),
4122 )?;
4123 match tagged.0 {
4124 __JSXExpressionOrEmptyTag::ArrayExpression => {
@@ -3219,7 +4313,7 @@ impl<'de> serde::Deserialize<'de> for JSXExpressionOrEmpty {
4313 }
4314 }
4315 #[derive(Serialize, Clone, Debug)]
3222 -#[serde(tag = "type")]
4316 +#[serde(untagged)]
4317 pub enum JSXAttributeOrSpread {
4318 JSXAttribute(Box<JSXAttribute>),
4319 JSXSpreadAttribute(Box<JSXSpreadAttribute>),
@@ -3238,7 +4332,7 @@ impl<'de> serde::Deserialize<'de> for JSXAttributeOrSpread {
4332 deserializer,
4333 serde::__private::de::TaggedContentVisitor::<
4334 __JSXAttributeOrSpreadTag,
3241 - >::new("type", "Pattern"),
4335 + >::new("type", "JSXAttributeOrSpread"),
4336 )?;
4337 match tagged.0 {
4338 __JSXAttributeOrSpreadTag::JSXAttribute => {
@@ -3261,7 +4355,7 @@ impl<'de> serde::Deserialize<'de> for JSXAttributeOrSpread {
4355 }
4356 }
4357 #[derive(Serialize, Clone, Debug)]
3264 -#[serde(tag = "type")]
4358 +#[serde(untagged)]
4359 pub enum JSXAttributeValue {
4360 JSXElement(Box<JSXElement>),
4361 JSXExpressionContainer(Box<JSXExpressionContainer>),
@@ -3284,7 +4378,7 @@ impl<'de> serde::Deserialize<'de> for JSXAttributeValue {
4378 deserializer,
4379 serde::__private::de::TaggedContentVisitor::<
4380 __JSXAttributeValueTag,
3287 - >::new("type", "Pattern"),
4381 + >::new("type", "JSXAttributeValue"),
4382 )?;
4383 match tagged.0 {
4384 __JSXAttributeValueTag::Literal => {
@@ -3323,7 +4417,7 @@ impl<'de> serde::Deserialize<'de> for JSXAttributeValue {
4417 }
4418 }
4419 #[derive(Serialize, Clone, Debug)]
3326 -#[serde(tag = "type")]
4420 +#[serde(untagged)]
4421 pub enum JSXElementName {
4422 JSXIdentifier(Box<JSXIdentifier>),
4423 JSXMemberExpression(Box<JSXMemberExpression>),
@@ -3344,7 +4438,7 @@ impl<'de> serde::Deserialize<'de> for JSXElementName {
4438 deserializer,
4439 serde::__private::de::TaggedContentVisitor::<
4440 __JSXElementNameTag,
3347 - >::new("type", "Pattern"),
4441 + >::new("type", "JSXElementName"),
4442 )?;
4443 match tagged.0 {
4444 __JSXElementNameTag::JSXIdentifier => {
@@ -3375,7 +4469,7 @@ impl<'de> serde::Deserialize<'de> for JSXElementName {
4469 }
4470 }
4471 #[derive(Serialize, Clone, Debug)]
3378 -#[serde(tag = "type")]
4472 +#[serde(untagged)]
4473 pub enum JSXIdentifierOrNamespacedName {
4474 JSXIdentifier(Box<JSXIdentifier>),
4475 JSXNamespacedName(Box<JSXNamespacedName>),
@@ -3394,7 +4488,7 @@ impl<'de> serde::Deserialize<'de> for JSXIdentifierOrNamespacedName {
4488 deserializer,
4489 serde::__private::de::TaggedContentVisitor::<
4490 __JSXIdentifierOrNamespacedNameTag,
3397 - >::new("type", "Pattern"),
4491 + >::new("type", "JSXIdentifierOrNamespacedName"),
4492 )?;
4493 match tagged.0 {
4494 __JSXIdentifierOrNamespacedNameTag::JSXIdentifier => {
@@ -3417,7 +4511,7 @@ impl<'de> serde::Deserialize<'de> for JSXIdentifierOrNamespacedName {
4511 }
4512 }
4513 #[derive(Serialize, Clone, Debug)]
3420 -#[serde(tag = "type")]
4514 +#[serde(untagged)]
4515 pub enum JSXChildItem {
4516 JSXElement(Box<JSXElement>),
4517 JSXExpressionContainer(Box<JSXExpressionContainer>),
@@ -3442,7 +4536,7 @@ impl<'de> serde::Deserialize<'de> for JSXChildItem {
4536 deserializer,
4537 serde::__private::de::TaggedContentVisitor::<
4538 __JSXChildItemTag,
3445 - >::new("type", "Pattern"),
4539 + >::new("type", "JSXChildItem"),
4540 )?;
4541 match tagged.0 {
4542 __JSXChildItemTag::JSXText => {
compiler/forget/crates/forget_estree/src/snapshots/forget_estree__tests__fixtures@for-statement.json.snap
+6
@@ -535,10 +535,12 @@ Input:
535
536 Output:
537 {
538 + "type": "Program",
539 "body": [
540 {
541 "type": "FunctionDeclaration",
542 "id": {
543 + "type": "Identifier",
544 "name": "Component",
545 "loc": {
546 "source": null,
@@ -578,12 +580,14 @@ Output:
580 }
581 ],
582 "body": {
583 + "type": "BlockStatement",
584 "body": [
585 {
586 "type": "VariableDeclaration",
587 "kind": "let",
588 "declarations": [
589 {
590 + "type": "VariableDeclarator",
591 "id": {
592 "type": "Identifier",
593 "name": "x",
@@ -662,9 +666,11 @@ Output:
666 {
667 "type": "ForStatement",
668 "init": {
669 + "type": "VariableDeclaration",
670 "kind": "let",
671 "declarations": [
672 {
673 + "type": "VariableDeclarator",
674 "id": {
675 "type": "Identifier",
676 "name": "i",
compiler/forget/crates/forget_estree/src/snapshots/forget_estree__tests__fixtures@import.json.snap
+3
@@ -111,6 +111,7 @@ Input:
111
112 Output:
113 {
114 + "type": "Program",
115 "body": [
116 {
117 "type": "ImportDeclaration",
@@ -118,6 +119,7 @@ Output:
119 {
120 "type": "ImportDefaultSpecifier",
121 "local": {
122 + "type": "Identifier",
123 "name": "React",
124 "loc": {
125 "source": null,
@@ -153,6 +155,7 @@ Output:
155 }
156 ],
157 "source": {
158 + "type": "Literal",
159 "value": {
160 "String": "react"
161 },
compiler/forget/crates/forget_estree/src/snapshots/forget_estree__tests__fixtures@simple.json.snap
+3
@@ -196,10 +196,12 @@ Input:
196
197 Output:
198 {
199 + "type": "Program",
200 "body": [
201 {
202 "type": "FunctionDeclaration",
203 "id": {
204 + "type": "Identifier",
205 "name": "Component",
206 "loc": {
207 "source": null,
@@ -239,6 +241,7 @@ Output:
241 }
242 ],
243 "body": {
244 + "type": "BlockStatement",
245 "body": [
246 {
247 "type": "ReturnStatement",
compiler/forget/crates/forget_estree/src/snapshots/forget_estree__tests__fixtures@test.json.snap
+7
@@ -358,10 +358,12 @@ Input:
358
359 Output:
360 {
361 + "type": "Program",
362 "body": [
363 {
364 "type": "FunctionDeclaration",
365 "id": {
366 + "type": "Identifier",
367 "name": "foo",
368 "loc": {
369 "source": null,
@@ -381,12 +383,14 @@ Output:
383 },
384 "params": [],
385 "body": {
386 + "type": "BlockStatement",
387 "body": [
388 {
389 "type": "ReturnStatement",
390 "argument": {
391 "type": "JSXElement",
392 "openingElement": {
393 + "type": "JSXOpeningElement",
394 "name": {
395 "type": "JSXMemberExpression",
396 "object": {
@@ -409,6 +413,7 @@ Output:
413 }
414 },
415 "property": {
416 + "type": "JSXIdentifier",
417 "name": "Bar",
418 "loc": {
419 "source": null,
@@ -541,6 +546,7 @@ Output:
546 },
547 "children": [],
548 "closingElement": {
549 + "type": "JSXClosingElement",
550 "name": {
551 "type": "JSXMemberExpression",
552 "object": {
@@ -563,6 +569,7 @@ Output:
569 }
570 },
571 "property": {
572 + "type": "JSXIdentifier",
573 "name": "Bar",
574 "loc": {
575 "source": null,
compiler/forget/crates/forget_estree_codegen/src/codegen.rs
+67 -28
@@ -21,7 +21,7 @@ pub fn estree() -> String {
21 }
22
23 #[derive(Serialize, Deserialize, Debug)]
24 -// #[serde(deny_unknown_fields)]
24 +#[serde(deny_unknown_fields)]
25 pub struct Grammar {
26 pub objects: IndexMap<String, Object>,
27 pub nodes: IndexMap<String, Node>,
@@ -57,7 +57,8 @@ impl Grammar {
57
58 quote! {
59 use std::num::NonZeroU32;
60 - use serde::{Serialize, Deserialize};
60 + use serde::ser::{Serializer, SerializeMap};
61 + use serde::{Serialize,Deserialize};
62 use crate::{JsValue, Binding, SourceRange};
63
64 #(#objects)*
@@ -72,7 +73,7 @@ impl Grammar {
73 }
74
75 #[derive(Serialize, Deserialize, Debug)]
75 -// #[serde(deny_unknown_fields)]
76 +#[serde(deny_unknown_fields)]
77 pub struct Object {
78 #[serde(default)]
79 pub fields: IndexMap<String, Field>,
@@ -97,14 +98,19 @@ impl Object {
98 }
99
100 #[derive(Serialize, Deserialize, Debug)]
100 -// #[serde(deny_unknown_fields)]
101 +#[serde(deny_unknown_fields)]
102 pub struct Node {
103 + #[serde(default)]
104 + #[serde(rename = "type")]
105 + pub type_: Option<String>,
106 +
107 #[serde(default)]
108 pub fields: IndexMap<String, Field>,
109 }
110
111 impl Node {
112 pub fn codegen(&self, name: &str) -> TokenStream {
113 + let name_str = name;
114 let name = format_ident!("{}", name);
115 let fields: Vec<_> = self
116 .fields
@@ -112,8 +118,37 @@ impl Node {
118 .map(|(name, field)| field.codegen_node(name))
119 .collect();
120
121 + let type_serializer = if let Some(type_) = &self.type_ {
122 + quote! {
123 + state.serialize_entry("type", #type_)?;
124 + }
125 + } else {
126 + quote! {
127 + state.serialize_entry("type", #name_str)?;
128 + }
129 + };
130 +
131 + let mut field_serializers = Vec::with_capacity(self.fields.len()); // type, loc, range
132 + for (field_name_str, field) in &self.fields {
133 + if field.skip {
134 + continue;
135 + }
136 + let field_name = format_ident!("{}", field_name_str);
137 + let serialized_field_name = field.rename.as_ref().unwrap_or(field_name_str);
138 + let serializer = if field.flatten {
139 + quote! {
140 + Serialize::serialize(&self.#field_name, serde::__private::ser::FlatMapSerializer(&mut state))?;
141 + }
142 + } else {
143 + quote! {
144 + state.serialize_entry(#serialized_field_name, &self.#field_name)?;
145 + }
146 + };
147 + field_serializers.push(serializer);
148 + }
149 +
150 quote! {
116 - #[derive(Serialize, Deserialize, Clone, Debug)]
151 + #[derive(Deserialize, Clone, Debug)]
152 pub struct #name {
153 #(#fields,)*
154
@@ -123,12 +158,26 @@ impl Node {
158 #[serde(default)]
159 pub range: Option<SourceRange>,
160 }
161 +
162 + impl Serialize for #name {
163 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
164 + where
165 + S: Serializer,
166 + {
167 + let mut state = serializer.serialize_map(None)?;
168 + #type_serializer
169 + #(#field_serializers)*
170 + state.serialize_entry("loc", &self.loc)?;
171 + state.serialize_entry("range", &self.range)?;
172 + state.end()
173 + }
174 + }
175 }
176 }
177 }
178
179 #[derive(Serialize, Deserialize, Debug)]
131 -// #[serde(deny_unknown_fields)]
180 +#[serde(deny_unknown_fields)]
181 pub struct Field {
182 #[serde(rename = "type")]
183 pub type_: String,
@@ -144,6 +193,10 @@ pub struct Field {
193
194 #[serde(default)]
195 pub skip: bool,
196 +
197 + #[serde(default)]
198 + #[serde(rename = "TODO")]
199 + pub todo: Option<String>,
200 }
201
202 impl Field {
@@ -217,7 +270,7 @@ impl Field {
270
271 #[derive(Serialize, Deserialize, Debug)]
272 #[serde(transparent)]
220 -// #[serde(deny_unknown_fields)]
273 +#[serde(deny_unknown_fields)]
274 pub struct Enum {
275 pub variants: Vec<String>,
276 }
@@ -227,6 +280,7 @@ impl Enum {
280 let mut sorted_variants: Vec<_> = self.variants.iter().collect();
281 sorted_variants.sort();
282
283 + let name_str = name;
284 let name = format_ident!("{}", name);
285 let variants: Vec<_> = sorted_variants
286 .iter()
@@ -240,24 +294,6 @@ impl Enum {
294 })
295 .collect();
296
243 - let enum_ = quote! {
244 - pub enum #name {
245 - #(#variants),*
246 - }
247 - };
248 - let enum_ = if sorted_variants.iter().any(|name| enums.contains_key(*name)) {
249 - // contains recursive enum, use untagged serialization
250 - quote! {
251 - #[serde(untagged)]
252 - #enum_
253 - }
254 - } else {
255 - quote! {
256 - #[serde(tag = "type")]
257 - #enum_
258 - }
259 - };
260 -
297 let enum_tag = format_ident!("__{}Tag", name);
298 let mut seen = HashSet::new();
299
@@ -325,7 +361,10 @@ impl Enum {
361 }
362 quote! {
363 #[derive(Serialize, Clone, Debug)]
328 - #enum_
364 + #[serde(untagged)]
365 + pub enum #name {
366 + #(#variants),*
367 + }
368
369 #[derive(Deserialize, Debug)]
370 enum #enum_tag {
@@ -337,7 +376,7 @@ impl Enum {
376 where D: serde::Deserializer<'de> {
377 let tagged = serde::Deserializer::deserialize_any(
378 deserializer,
340 - serde::__private::de::TaggedContentVisitor::<#enum_tag>::new("type", "Pattern")
379 + serde::__private::de::TaggedContentVisitor::<#enum_tag>::new("type", #name_str)
380 )?;
381 match tagged.0 {
382 #(#tag_matches),*
@@ -350,7 +389,7 @@ impl Enum {
389
390 #[derive(Serialize, Deserialize, Debug)]
391 #[serde(transparent)]
353 -// #[serde(deny_unknown_fields)]
392 +#[serde(deny_unknown_fields)]
393 pub struct Operator {
394 pub variants: IndexMap<String, String>,
395 }
compiler/forget/crates/forget_estree_codegen/src/ecmascript.json
+1 -1
@@ -780,7 +780,7 @@
780 }
781 },
782 "AssignmentProperty": {
783 - "tag": "Property",
783 + "type": "Property",
784 "fields": {
785 "key": {
786 "type": "PropertyKey"