1#![allow(unexpected_cfgs)]
2
3use swc_atoms::Atom;
4use swc_common::{ast_node, Span};
5
6#[ast_node]
8#[derive(Eq)]
9pub struct Text {
10 pub span: Span,
11 pub value: Atom,
12}
13
14#[ast_node]
15pub struct JsDoc {
16 pub span: Span,
17
18 pub description: Text,
19 pub tags: Vec<TagItem>,
20}
21
22#[ast_node]
24pub struct TagItem {
25 pub span: Span,
26 #[cfg_attr(feature = "serde-impl", serde(rename = "tagName"))]
27 pub tag_name: Text,
28 #[cfg_attr(feature = "serde-impl", serde(flatten))]
29 pub tag: Tag,
30}
31
32#[ast_node(no_unknown)]
33pub enum Tag {
34 #[tag("Yield")]
35 Yield(YieldTag),
36 #[tag("TypeDef")]
37 TypeDef(TypeDefTag),
38 #[tag("Throw")]
39 Throw(ThrowTag),
40 #[tag("Todo")]
41 Todo(TodoTag),
42 #[tag("Tutorial")]
43 Tutorial(TutorialTag),
44 #[tag("Static")]
45 Static(StaticTag),
46 #[tag("Summary")]
47 Summary(SummaryTag),
48 #[tag("See")]
49 See(SeeTag),
50 #[tag("Since")]
51 Since(SinceTag),
52 #[tag("Requires")]
53 Requires(RequiresTag),
54 #[tag("Override")]
55 Override(OverrideTag),
56 #[tag("Package")]
57 Package(PackageTag),
58 #[tag("Module")]
59 Module(ModuleTag),
60 #[tag("Name")]
61 Name(NameTag),
62 #[tag("Namespace")]
63 Namespace(NamespaceTag),
64 #[tag("Variation")]
65 Variation(VariationTag),
66 #[tag("Version")]
67 Version(VersionTag),
68 #[tag("MemberOf")]
69 MemberOf(MemberOfTag),
70 #[tag("Mixes")]
71 Mixes(MixesTag),
72 #[tag("Mixin")]
73 Mixin(MixinTag),
74 #[tag("Member")]
75 Member(MemberTag),
76 #[tag("Listens")]
77 Listens(ListensTag),
78 #[tag("License")]
79 License(LicenseTag),
80 #[tag("Kind")]
81 Kind(KindTag),
82 #[tag("Lends")]
83 Lends(LendsTag),
84 #[tag("Instance")]
85 Instance(InstanceTag),
86 #[tag("Interface")]
87 Interface(InterfaceTag),
88 #[tag("Inner")]
89 Inner(InnerTag),
90 #[tag("InheritDoc")]
91 InheritDoc(InheritDocTag),
92 #[tag("IgnoreTag")]
93 Ignore(IgnoreTag),
94 #[tag("HideConstructorTag")]
95 HideConstructor(HideConstructorTag),
96 #[tag("GeneratorTag")]
97 Generator(GeneratorTag),
98 #[tag("FunctionTag")]
99 Function(FunctionTag),
100 #[tag("FileTag")]
101 File(FileTag),
102 #[tag("ConstructsTag")]
103 Constructs(ConstructsTag),
104 #[tag("CopyrightTag")]
105 Copyright(CopyrightTag),
106 #[tag("AbstractTag")]
107 Abstract(AbstractTag),
108 #[tag("AccessTag")]
109 Access(AccessTag),
110 #[tag("AliasTag")]
111 Alias(AliasTag),
112 #[tag("AsyncTag")]
113 Async(AsyncTag),
114 #[tag("UnknownTag")]
115 Unknown(UnknownTag),
116 #[tag("AugmentsTag")]
117 Augments(AugmentsTag),
118 #[tag("ImplementsTag")]
119 Implements(ImplementsTag),
120 #[tag("AuthorTag")]
121 Author(AuthorTag),
122 #[tag("BorrowsTag")]
123 Borrows(BorrowsTag),
124 #[tag("ClassTag")]
125 Class(ClassTag),
126 #[tag("JSDocClassDescTag")]
127 ClassDesc(JSDocClassDescTag),
128 #[tag("ConstTag")]
129 Const(ConstTag),
130 #[tag("PublicTag")]
131 Public(PublicTag),
132 #[tag("PrivateTag")]
133 Private(PrivateTag),
134 #[tag("ProtectedTag")]
135 Protected(ProtectedTag),
136 #[tag("ReadonlyTag")]
137 Readonly(ReadonlyTag),
138 #[tag("CallbackTag")]
139 Callback(CallbackTag),
140 #[tag("EnumTag")]
141 Enum(EnumTag),
142 #[tag("ParameterTag")]
143 Parameter(ParameterTag),
144 #[tag("ReturnTag")]
145 Return(ReturnTag),
146 #[tag("ThisTag")]
147 This(ThisTag),
148 #[tag("TypeTag")]
149 Type(TypeTag),
150 #[tag("TemplateTag")]
151 Template(TemplateTag),
152 #[tag("TypedefTag")]
153 Typedef(TypedefTag),
154 #[tag("PropertyTag")]
155 Property(PropertyTag),
156 #[tag("DescriptionTag")]
157 Description(DescriptionTag),
158 #[tag("ExampleTag")]
159 Example(ExampleTag),
160 #[tag("ExportsTag")]
161 Exports(ExportsTag),
162 #[tag("ExternalTag")]
163 External(ExternalTag),
164 #[tag("DefaultTag")]
165 Default(DefaultTag),
166 #[tag("DeprecatedTag")]
167 Deprecated(DeprecatedTag),
168}
169
170#[ast_node]
171pub struct AbstractTag {
172 pub span: Span,
173}
174
175#[ast_node]
176pub struct AccessTag {
177 pub span: Span,
178 pub access: Text,
179}
180
181#[ast_node]
182pub struct AliasTag {
183 pub span: Span,
184 pub name_path: NamePath,
185}
186
187#[ast_node]
188pub struct AsyncTag {
189 pub span: Span,
190}
191
192#[ast_node]
193pub struct BorrowsTag {
194 pub span: Span,
195 pub from: NamePath,
196 pub to: NamePath,
197}
198
199#[ast_node]
200pub struct JSDocClassDescTag {
201 pub span: Span,
202 pub desc: Text,
203}
204
205#[ast_node]
206pub struct ConstTag {
207 pub span: Span,
208 #[cfg_attr(
209 feature = "encoding-impl",
210 encoding(with = "cbor4ii::core::types::Maybe")
211 )]
212 pub ty: Option<Text>,
213 #[cfg_attr(
214 feature = "encoding-impl",
215 encoding(with = "cbor4ii::core::types::Maybe")
216 )]
217 pub name: Option<Text>,
218}
219
220#[ast_node]
221pub struct UnknownTag {
222 pub span: Span,
223 pub extras: Text,
224}
225
226#[ast_node]
228pub struct AugmentsTag {
229 pub span: Span,
230 pub class: NamePath,
231}
232
233#[ast_node]
234pub struct ImplementsTag {
235 pub span: Span,
236 pub class: Text,
237}
238
239#[ast_node]
240pub struct ExprWithTypeArgs {
241 pub span: Span,
242
243 pub expr: Box<Expr>,
245}
246
247#[ast_node]
248pub enum Expr {
249 #[tag("Identifier")]
250 Text(Text),
251 #[tag("NamePath")]
252 Property(NamePath),
253}
254
255#[ast_node]
256pub struct AuthorTag {
257 pub span: Span,
258 pub author: Text,
260}
261
262#[ast_node]
263#[derive(Eq)]
264pub struct ClassTag {
265 pub span: Span,
266 #[cfg_attr(
267 feature = "encoding-impl",
268 encoding(with = "cbor4ii::core::types::Maybe")
269 )]
270 pub ty: Option<Text>,
271 #[cfg_attr(
272 feature = "encoding-impl",
273 encoding(with = "cbor4ii::core::types::Maybe")
274 )]
275 pub name: Option<Text>,
276}
277
278#[ast_node]
279#[derive(Eq)]
280pub struct PublicTag {
281 pub span: Span,
282}
283
284#[ast_node]
285#[derive(Eq)]
286pub struct PrivateTag {
287 pub span: Span,
288 #[cfg_attr(
289 feature = "encoding-impl",
290 encoding(with = "cbor4ii::core::types::Maybe")
291 )]
292 pub ty: Option<Text>,
293}
294
295#[ast_node]
296#[derive(Eq)]
297pub struct ProtectedTag {
298 pub span: Span,
299 #[cfg_attr(
300 feature = "encoding-impl",
301 encoding(with = "cbor4ii::core::types::Maybe")
302 )]
303 pub ty: Option<Text>,
304}
305
306#[ast_node]
307#[derive(Eq)]
308pub struct ReadonlyTag {
309 pub span: Span,
310}
311
312#[ast_node]
313pub struct CallbackTag {
314 pub span: Span,
315 pub name_path: NamePath,
316}
317
318#[ast_node]
319pub struct PropertyTag {
320 pub span: Span,
321
322 pub name_path: NamePath,
323 #[cfg_attr(
324 feature = "encoding-impl",
325 encoding(with = "cbor4ii::core::types::Maybe")
326 )]
327 pub ty: Option<Text>,
328 pub desc: Text,
329}
330
331#[ast_node]
332pub struct ParameterTag {
333 pub span: Span,
334
335 #[cfg_attr(
336 feature = "encoding-impl",
337 encoding(with = "cbor4ii::core::types::Maybe")
338 )]
339 pub name: Option<Text>,
340 #[cfg_attr(feature = "serde-impl", serde(rename = "typeExpression"))]
341 #[cfg_attr(
342 feature = "encoding-impl",
343 encoding(with = "cbor4ii::core::types::Maybe")
344 )]
345 pub ty: Option<Text>,
346
347 pub desc: Text,
348}
349
350#[ast_node]
351#[derive(Eq)]
352pub struct EnumTag {
353 pub span: Span,
354 pub ty: Text,
355}
356
357#[ast_node]
358pub struct ReturnTag {
359 pub span: Span,
360 #[cfg_attr(
361 feature = "encoding-impl",
362 encoding(with = "cbor4ii::core::types::Maybe")
363 )]
364 pub ty: Option<Text>,
365 pub description: Text,
366}
367
368#[ast_node]
369pub struct ThisTag {
370 pub span: Span,
371 pub name_path: NamePath,
372}
373
374#[ast_node]
375pub struct TypeTag {
376 pub span: Span,
377 pub name: Text,
378}
379
380#[ast_node]
381pub struct TemplateTag {
382 pub span: Span,
383 #[cfg_attr(
384 feature = "encoding-impl",
385 encoding(with = "cbor4ii::core::types::Maybe")
386 )]
387 pub constraint: Option<TypeExpr>,
388}
389
390#[ast_node]
391pub struct TypedefTag {
392 pub span: Span,
393 #[cfg_attr(feature = "serde-impl", serde(rename = "full_name"))]
394 #[cfg_attr(
395 feature = "encoding-impl",
396 encoding(with = "cbor4ii::core::types::Maybe")
397 )]
398 pub full_name: Option<NamespaceBody>,
399
400 #[cfg_attr(
401 feature = "encoding-impl",
402 encoding(with = "cbor4ii::core::types::Maybe")
403 )]
404 pub name: Option<Text>,
405 #[cfg_attr(feature = "serde-impl", serde(rename = "typeExpression"))]
406 #[cfg_attr(
407 feature = "encoding-impl",
408 encoding(with = "cbor4ii::core::types::Maybe")
409 )]
410 pub type_expr: Option<TypeExprOrTypeLit>,
411}
412
413#[ast_node(no_unknown)]
414pub enum Type {
415 #[tag("AllType")]
417 All(AllType),
418 #[tag("UnknownType")]
420 Unknown(UnknownType),
421 #[tag("NullableType")]
422 Nullable(NullableType),
423 #[tag("NonNullableType")]
424 NonNullable(NonNullableType),
425 #[tag("OptionalType")]
426 Optional(OptionalType),
427 #[tag("FunctionType")]
428 Function(FunctionType),
429 #[tag("VariadicType")]
430 Variadic(VariadicType),
431 #[tag("NamePathType")]
433 NamePath(NamePathType),
434 #[tag("UnionType")]
435 Union(UnionType),
436 #[tag("ParenType")]
437 Paren(ParenType),
438}
439
440#[ast_node]
441pub struct UnionType {
442 pub span: Span,
443 pub types: Vec<Type>,
444}
445
446#[ast_node]
447pub struct ParenType {
448 pub span: Span,
449 pub ty: Box<Type>,
450}
451
452#[ast_node]
453#[derive(Eq)]
454pub struct AllType {
455 pub span: Span,
456}
457
458#[ast_node]
459#[derive(Eq)]
460pub struct UnknownType {
461 pub span: Span,
462}
463
464#[ast_node]
465pub struct NullableType {
466 pub span: Span,
467 pub ty: Box<Type>,
468}
469
470#[ast_node]
471pub struct NonNullableType {
472 pub span: Span,
473 pub ty: Box<Type>,
474}
475
476#[ast_node]
477pub struct OptionalType {
478 pub span: Span,
479 pub ty: Box<Type>,
480}
481
482#[ast_node]
484pub struct FunctionType {
485 pub span: Span,
486 pub ty: Box<Type>,
487}
488
489#[ast_node]
490pub struct VariadicType {
491 pub span: Span,
492 pub ty: Box<Type>,
493}
494
495#[ast_node]
496pub struct NamePathType {
497 pub span: Span,
498 pub ty: Box<Type>,
499}
500
501#[ast_node]
503pub struct TypeExpr {
504 pub span: Span,
505 pub ty: Type,
506}
507
508#[ast_node]
509pub struct NamespaceDecl {
510 pub span: Span,
511 pub name: Text,
512 pub body: Vec<NamespaceBody>,
513}
514
515#[ast_node]
516pub enum NamespaceBody {
517 #[tag("Identifier")]
518 Text(Box<Text>),
519 #[tag("NamespaceDecl")]
520 Decl(Box<NamespaceDecl>),
521}
522
523#[ast_node]
524pub enum TypeExprOrTypeLit {
525 #[tag("TypeExpr")]
526 Expr(Box<TypeExpr>),
527 #[tag("TypeLit")]
528 TypeLit(Box<TypeLit>),
529}
530
531#[ast_node]
532pub struct TypeLit {
533 pub span: Span,
534 pub tags: Vec<PropOrParam>,
535 pub is_array_type: bool,
537}
538
539#[ast_node]
540pub enum PropOrParam {
541 #[tag("PropertyTag")]
542 Prop(PropertyTag),
543 #[tag("ParameterTag")]
544 Param(ParameterTag),
545}
546
547#[ast_node]
548pub struct NamePath {
549 pub span: Span,
550 pub components: Vec<Text>,
551}
552
553#[ast_node]
554pub struct CopyrightTag {
555 pub span: Span,
556 pub text: Text,
557}
558
559#[ast_node]
560pub struct DescriptionTag {
561 pub span: Span,
562 pub text: Text,
563}
564
565#[ast_node]
566pub struct ExampleTag {
567 pub span: Span,
568 pub text: Text,
569}
570
571#[ast_node]
572pub struct ExportsTag {
573 pub span: Span,
574 pub module_name: Text,
575}
576
577#[ast_node]
578pub struct ExternalTag {
579 pub span: Span,
580 pub name: Text,
581}
582
583#[ast_node]
584pub struct ConstructsTag {
585 pub span: Span,
586 pub name: Text,
587}
588
589#[ast_node]
590pub struct DefaultTag {
591 pub span: Span,
592 pub value: Text,
593}
594
595#[ast_node]
596pub struct DeprecatedTag {
597 pub span: Span,
598 pub text: Text,
599}
600
601#[ast_node]
602pub struct FileTag {
603 pub span: Span,
604 pub text: Text,
605}
606
607#[ast_node]
608pub struct FunctionTag {
609 pub span: Span,
610 #[cfg_attr(
611 feature = "encoding-impl",
612 encoding(with = "cbor4ii::core::types::Maybe")
613 )]
614 pub name: Option<Text>,
615}
616
617#[ast_node]
618pub struct GeneratorTag {
619 pub span: Span,
620}
621#[ast_node]
622pub struct HideConstructorTag {
623 pub span: Span,
624}
625
626#[ast_node]
627pub struct IgnoreTag {
628 pub span: Span,
629}
630
631#[ast_node]
632pub struct InheritDocTag {
633 pub span: Span,
634}
635
636#[ast_node]
637pub struct InnerTag {
638 pub span: Span,
639}
640
641#[ast_node]
642pub struct InstanceTag {
643 pub span: Span,
644}
645
646#[ast_node]
647pub struct InterfaceTag {
648 pub span: Span,
649 #[cfg_attr(
650 feature = "encoding-impl",
651 encoding(with = "cbor4ii::core::types::Maybe")
652 )]
653 pub name: Option<Text>,
654}
655#[ast_node]
656pub struct KindTag {
657 pub span: Span,
658 pub name: Text,
659}
660
661#[ast_node]
662pub struct LendsTag {
663 pub span: Span,
664 pub name: NamePath,
665}
666
667#[ast_node]
668pub struct LicenseTag {
669 pub span: Span,
670 pub identifier: Text,
671}
672
673#[ast_node]
674pub struct ListensTag {
675 pub span: Span,
676 pub event_name: Text,
677}
678
679#[ast_node]
680pub struct MemberTag {
681 pub span: Span,
682 pub ty: Text,
683 pub name: Text,
684}
685
686#[ast_node]
687pub struct MemberOfTag {
688 pub span: Span,
689 pub parent_name_path: NamePath,
690}
691
692#[ast_node]
693pub struct TypeDefTag {
694 pub span: Span,
695 #[cfg_attr(
696 feature = "encoding-impl",
697 encoding(with = "cbor4ii::core::types::Maybe")
698 )]
699 pub ty: Option<Text>,
700 pub name_path: NamePath,
701}
702
703#[ast_node]
704pub struct MixesTag {
705 pub span: Span,
706 pub name_path: NamePath,
707}
708
709#[ast_node]
710pub struct MixinTag {
711 pub span: Span,
712 pub name: Text,
713}
714
715#[ast_node]
716pub struct ModuleTag {
717 pub span: Span,
718 pub name: Text,
719 pub ty: Text,
720}
721
722#[ast_node]
723pub struct NameTag {
724 pub span: Span,
725 pub name_path: NamePath,
726}
727
728#[ast_node]
729pub struct NamespaceTag {
730 pub span: Span,
731 #[cfg_attr(
732 feature = "encoding-impl",
733 encoding(with = "cbor4ii::core::types::Maybe")
734 )]
735 pub ty: Option<Text>,
736 #[cfg_attr(
737 feature = "encoding-impl",
738 encoding(with = "cbor4ii::core::types::Maybe")
739 )]
740 pub name: Option<Text>,
741}
742
743#[ast_node]
744pub struct OverrideTag {
745 pub span: Span,
746}
747
748#[ast_node]
749pub struct PackageTag {
750 pub span: Span,
751 #[cfg_attr(
752 feature = "encoding-impl",
753 encoding(with = "cbor4ii::core::types::Maybe")
754 )]
755 pub ty: Option<Text>,
756}
757
758#[ast_node]
759pub struct RequiresTag {
760 pub span: Span,
761 pub name_path: NamePath,
762}
763
764#[ast_node]
765pub struct SeeTag {
766 pub span: Span,
767 pub text: Text,
768}
769
770#[ast_node]
771pub struct SinceTag {
772 pub span: Span,
773 pub version: Text,
774}
775
776#[ast_node]
777pub struct SummaryTag {
778 pub span: Span,
779 pub text: Text,
780}
781
782#[ast_node]
783pub struct StaticTag {
784 pub span: Span,
785}
786
787#[ast_node]
788pub struct ThrowTag {
789 pub span: Span,
790 pub text: Text,
791}
792
793#[ast_node]
794pub struct TodoTag {
795 pub span: Span,
796 pub text: Text,
797}
798
799#[ast_node]
800pub struct TutorialTag {
801 pub span: Span,
802 pub text: Text,
803}
804
805#[ast_node]
806pub struct VariationTag {
807 pub span: Span,
808 pub number: Text,
809}
810
811#[ast_node]
812pub struct VersionTag {
813 pub span: Span,
814 pub value: Text,
815}
816
817#[ast_node]
818pub struct YieldTag {
819 pub span: Span,
820 #[cfg_attr(
821 feature = "encoding-impl",
822 encoding(with = "cbor4ii::core::types::Maybe")
823 )]
824 pub value: Option<Text>,
825 pub description: Text,
826}