TypeScript_Rust_Compiler/
ast.rs

1//! Abstract Syntax Tree (AST) definitions for TypeScript
2
3use serde::{Deserialize, Serialize};
4
5/// Root program node
6#[derive(Debug, Clone, Serialize, Deserialize)]
7pub struct Program {
8    pub statements: Vec<Statement>,
9}
10
11/// Statement types
12#[derive(Debug, Clone, Serialize, Deserialize)]
13pub enum Statement {
14    VariableDeclaration(VariableDeclaration),
15    FunctionDeclaration(FunctionDeclaration),
16    ClassDeclaration(ClassDeclaration),
17    InterfaceDeclaration(InterfaceDeclaration),
18    TypeAlias(TypeAlias),
19    EnumDeclaration(EnumDeclaration),
20    ImportDeclaration(ImportDeclaration),
21    ExportDeclaration(Box<ExportDeclaration>),
22    NamespaceDeclaration(NamespaceDeclaration),
23    ModuleDeclaration(ModuleDeclaration),
24    DeclareStatement(Box<DeclareStatement>),
25    BlockStatement(BlockStatement),
26    ExpressionStatement(ExpressionStatement),
27    IfStatement(Box<IfStatement>),
28    WhileStatement(WhileStatement),
29    ForStatement(ForStatement),
30    ReturnStatement(ReturnStatement),
31    BreakStatement(BreakStatement),
32    ContinueStatement(ContinueStatement),
33    ThrowStatement(ThrowStatement),
34    TryStatement(Box<TryStatement>),
35    SwitchStatement(SwitchStatement),
36}
37
38/// Variable declaration
39#[derive(Debug, Clone, Serialize, Deserialize)]
40pub struct VariableDeclaration {
41    pub keyword: crate::lexer::Keyword,
42    pub name: String,
43    pub type_annotation: Option<Type>,
44    pub initializer: Option<Expression>,
45}
46
47/// Function declaration
48#[derive(Debug, Clone, Serialize, Deserialize)]
49pub struct FunctionDeclaration {
50    pub name: String,
51    pub type_parameters: Vec<TypeParameter>,
52    pub parameters: Vec<Parameter>,
53    pub return_type: Option<Type>,
54    pub body: Box<Statement>,
55}
56
57/// Class declaration
58#[derive(Debug, Clone, Serialize, Deserialize)]
59pub struct ClassDeclaration {
60    pub name: String,
61    pub type_parameters: Vec<TypeParameter>,
62    pub extends: Option<Type>,
63    pub implements: Vec<Type>,
64    pub body: ClassBody,
65}
66
67/// Interface declaration
68#[derive(Debug, Clone, Serialize, Deserialize)]
69pub struct InterfaceDeclaration {
70    pub name: String,
71    pub type_parameters: Vec<TypeParameter>,
72    pub extends: Vec<Type>,
73    pub body: InterfaceBody,
74}
75
76/// Type alias
77#[derive(Debug, Clone, Serialize, Deserialize)]
78pub struct TypeAlias {
79    pub name: String,
80    pub type_parameters: Vec<TypeParameter>,
81    pub type_definition: Type,
82}
83
84/// Enum declaration
85#[derive(Debug, Clone, Serialize, Deserialize)]
86pub struct EnumDeclaration {
87    pub name: String,
88    pub members: Vec<EnumMember>,
89}
90
91/// Import declaration
92#[derive(Debug, Clone, Serialize, Deserialize)]
93pub struct ImportDeclaration {
94    pub specifiers: Vec<ImportSpecifier>,
95    pub source: String,
96}
97
98/// Export declaration
99#[derive(Debug, Clone, Serialize, Deserialize)]
100pub struct ExportDeclaration {
101    pub declaration: Box<Statement>,
102}
103
104/// Namespace declaration
105#[derive(Debug, Clone, Serialize, Deserialize)]
106pub struct NamespaceDeclaration {
107    pub name: String,
108    pub body: Box<Statement>,
109}
110
111/// Module declaration
112#[derive(Debug, Clone, Serialize, Deserialize)]
113pub struct ModuleDeclaration {
114    pub name: String,
115    pub body: Box<Statement>,
116}
117
118/// Declare statement
119#[derive(Debug, Clone, Serialize, Deserialize)]
120pub struct DeclareStatement {
121    pub declaration: Box<Statement>,
122}
123
124/// Block statement
125#[derive(Debug, Clone, Serialize, Deserialize)]
126pub struct BlockStatement {
127    pub statements: Vec<Statement>,
128}
129
130/// Expression statement
131#[derive(Debug, Clone, Serialize, Deserialize)]
132pub struct ExpressionStatement {
133    pub expression: Expression,
134}
135
136/// If statement
137#[derive(Debug, Clone, Serialize, Deserialize)]
138pub struct IfStatement {
139    pub condition: Expression,
140    pub consequent: Box<Statement>,
141    pub alternate: Option<Statement>,
142}
143
144/// While statement
145#[derive(Debug, Clone, Serialize, Deserialize)]
146pub struct WhileStatement {
147    pub condition: Expression,
148    pub body: Box<Statement>,
149}
150
151/// For statement
152#[derive(Debug, Clone, Serialize, Deserialize)]
153pub struct ForStatement {
154    pub init: Option<Expression>,
155    pub condition: Option<Expression>,
156    pub update: Option<Expression>,
157    pub body: Box<Statement>,
158}
159
160/// Return statement
161#[derive(Debug, Clone, Serialize, Deserialize)]
162pub struct ReturnStatement {
163    pub argument: Option<Expression>,
164}
165
166/// Break statement
167#[derive(Debug, Clone, Serialize, Deserialize)]
168pub struct BreakStatement {
169    pub label: Option<String>,
170}
171
172/// Continue statement
173#[derive(Debug, Clone, Serialize, Deserialize)]
174pub struct ContinueStatement {
175    pub label: Option<String>,
176}
177
178/// Throw statement
179#[derive(Debug, Clone, Serialize, Deserialize)]
180pub struct ThrowStatement {
181    pub argument: Expression,
182}
183
184/// Try statement
185#[derive(Debug, Clone, Serialize, Deserialize)]
186pub struct TryStatement {
187    pub block: Box<Statement>,
188    pub handler: Option<CatchClause>,
189    pub finalizer: Option<Statement>,
190}
191
192/// Switch statement
193#[derive(Debug, Clone, Serialize, Deserialize)]
194pub struct SwitchStatement {
195    pub discriminant: Expression,
196    pub cases: Vec<SwitchCase>,
197}
198
199/// Expression types
200#[derive(Debug, Clone, Serialize, Deserialize)]
201pub enum Expression {
202    Literal(Literal),
203    Identifier(String),
204    Binary(BinaryExpression),
205    Unary(UnaryExpression),
206    Logical(LogicalExpression),
207    Conditional(ConditionalExpression),
208    Assignment(AssignmentExpression),
209    Call(CallExpression),
210    Member(MemberExpression),
211    Array(ArrayExpression),
212    Object(ObjectExpression),
213    Parenthesized(ParenthesizedExpression),
214    Arrow(Box<ArrowFunctionExpression>),
215    New(NewExpression),
216    Super(SuperExpression),
217    This(ThisExpression),
218    Yield(Box<YieldExpression>),
219    Await(AwaitExpression),
220    TypeAssertion(TypeAssertion),
221    AsExpression(AsExpression),
222    NonNull(NonNullExpression),
223    Optional(OptionalExpression),
224    Template(TemplateLiteral),
225    TaggedTemplate(TaggedTemplateExpression),
226}
227
228/// Literal values
229#[derive(Debug, Clone, Serialize, Deserialize)]
230pub enum Literal {
231    String(String),
232    Number(f64),
233    Boolean(bool),
234    Null,
235    Undefined,
236    RegExp(String, String), // pattern, flags
237    BigInt(String),
238}
239
240/// Binary expression
241#[derive(Debug, Clone, Serialize, Deserialize)]
242pub struct BinaryExpression {
243    pub left: Box<Expression>,
244    pub operator: crate::lexer::Token,
245    pub right: Box<Expression>,
246}
247
248/// Unary expression
249#[derive(Debug, Clone, Serialize, Deserialize)]
250pub struct UnaryExpression {
251    pub operator: crate::lexer::Token,
252    pub argument: Box<Expression>,
253}
254
255/// Logical expression
256#[derive(Debug, Clone, Serialize, Deserialize)]
257pub struct LogicalExpression {
258    pub left: Box<Expression>,
259    pub operator: crate::lexer::Token,
260    pub right: Box<Expression>,
261}
262
263/// Conditional expression
264#[derive(Debug, Clone, Serialize, Deserialize)]
265pub struct ConditionalExpression {
266    pub test: Box<Expression>,
267    pub consequent: Box<Expression>,
268    pub alternate: Box<Expression>,
269}
270
271/// Assignment expression
272#[derive(Debug, Clone, Serialize, Deserialize)]
273pub struct AssignmentExpression {
274    pub left: Box<Expression>,
275    pub operator: crate::lexer::Token,
276    pub right: Box<Expression>,
277}
278
279/// Call expression
280#[derive(Debug, Clone, Serialize, Deserialize)]
281pub struct CallExpression {
282    pub callee: Box<Expression>,
283    pub arguments: Vec<Expression>,
284}
285
286/// Member expression
287#[derive(Debug, Clone, Serialize, Deserialize)]
288pub struct MemberExpression {
289    pub object: Box<Expression>,
290    pub property: Box<Expression>,
291    pub computed: bool,
292}
293
294/// Array expression
295#[derive(Debug, Clone, Serialize, Deserialize)]
296pub struct ArrayExpression {
297    pub elements: Vec<Option<Expression>>,
298}
299
300/// Object expression
301#[derive(Debug, Clone, Serialize, Deserialize)]
302pub struct ObjectExpression {
303    pub properties: Vec<ObjectProperty>,
304}
305
306/// Object property
307#[derive(Debug, Clone, Serialize, Deserialize)]
308pub struct ObjectProperty {
309    pub key: Expression,
310    pub value: Expression,
311    pub shorthand: bool,
312    pub computed: bool,
313    pub method: bool,
314}
315
316/// Parenthesized expression
317#[derive(Debug, Clone, Serialize, Deserialize)]
318pub struct ParenthesizedExpression {
319    pub expression: Box<Expression>,
320}
321
322/// Arrow function expression
323#[derive(Debug, Clone, Serialize, Deserialize)]
324pub struct ArrowFunctionExpression {
325    pub type_parameters: Vec<TypeParameter>,
326    pub parameters: Vec<Parameter>,
327    pub return_type: Option<Box<Type>>,
328    pub body: Box<Statement>,
329}
330
331/// New expression
332#[derive(Debug, Clone, Serialize, Deserialize)]
333pub struct NewExpression {
334    pub callee: Box<Expression>,
335    pub arguments: Vec<Expression>,
336}
337
338/// Super expression
339#[derive(Debug, Clone, Serialize, Deserialize)]
340pub struct SuperExpression;
341
342/// This expression
343#[derive(Debug, Clone, Serialize, Deserialize)]
344pub struct ThisExpression;
345
346/// Yield expression
347#[derive(Debug, Clone, Serialize, Deserialize)]
348pub struct YieldExpression {
349    pub argument: Option<Box<Expression>>,
350    pub delegate: bool,
351}
352
353/// Await expression
354#[derive(Debug, Clone, Serialize, Deserialize)]
355pub struct AwaitExpression {
356    pub argument: Box<Expression>,
357}
358
359/// Type assertion
360#[derive(Debug, Clone, Serialize, Deserialize)]
361pub struct TypeAssertion {
362    pub expression: Box<Expression>,
363    pub type_: Type,
364}
365
366/// As expression
367#[derive(Debug, Clone, Serialize, Deserialize)]
368pub struct AsExpression {
369    pub expression: Box<Expression>,
370    pub type_: Type,
371}
372
373/// Non-null expression
374#[derive(Debug, Clone, Serialize, Deserialize)]
375pub struct NonNullExpression {
376    pub expression: Box<Expression>,
377}
378
379/// Optional expression
380#[derive(Debug, Clone, Serialize, Deserialize)]
381pub struct OptionalExpression {
382    pub expression: Box<Expression>,
383    pub optional: bool,
384}
385
386/// Template literal
387#[derive(Debug, Clone, Serialize, Deserialize)]
388pub struct TemplateLiteral {
389    pub quasis: Vec<TemplateElement>,
390    pub expressions: Vec<Expression>,
391}
392
393/// Template element
394#[derive(Debug, Clone, Serialize, Deserialize)]
395pub struct TemplateElement {
396    pub value: String,
397    pub tail: bool,
398}
399
400/// Tagged template expression
401#[derive(Debug, Clone, Serialize, Deserialize)]
402pub struct TaggedTemplateExpression {
403    pub tag: Box<Expression>,
404    pub quasi: TemplateLiteral,
405}
406
407/// Type definitions
408#[derive(Debug, Clone, Serialize, Deserialize)]
409pub enum Type {
410    // Primitive types
411    String,
412    Number,
413    Boolean,
414    Any,
415    Void,
416    Never,
417    Unknown,
418    Null,
419    Undefined,
420    Object,
421    Symbol,
422    BigInt,
423
424    // Named types
425    Named(String),
426    Qualified(QualifiedTypeName),
427
428    // Generic types
429    Generic(GenericType),
430    GenericNamed { name: String, type_parameters: Vec<TypeParameter> },
431
432    // Union and intersection types
433    Union(Vec<Type>),
434    Intersection(Vec<Type>),
435
436    // Array and tuple types
437    Array(Box<Type>),
438    Tuple(Vec<Type>),
439
440    // Function types
441    Function(Box<FunctionType>),
442
443    // Object types
444    ObjectType(ObjectType),
445
446    // Index signatures
447    IndexSignature(Box<IndexSignature>),
448
449    // Mapped types
450    Mapped(Box<MappedType>),
451
452    // Conditional types
453    Conditional(ConditionalType),
454
455    // Template literal types
456    TemplateLiteral(TemplateLiteralType),
457
458    // Parenthesized types
459    Parenthesized(Box<Type>),
460
461    // Type queries
462    TypeQuery(Box<TypeQuery>),
463
464    // Import types
465    Import(Box<ImportType>),
466}
467
468/// Qualified type name
469#[derive(Debug, Clone, Serialize, Deserialize)]
470pub struct QualifiedTypeName {
471    pub left: Box<Type>,
472    pub right: String,
473}
474
475/// Generic type
476#[derive(Debug, Clone, Serialize, Deserialize)]
477pub struct GenericType {
478    pub type_: Box<Type>,
479    pub type_arguments: Vec<Type>,
480}
481
482/// Function type
483#[derive(Debug, Clone, Serialize, Deserialize)]
484pub struct FunctionType {
485    pub type_parameters: Vec<TypeParameter>,
486    pub parameters: Vec<Parameter>,
487    pub return_type: Box<Type>,
488}
489
490/// Object type
491#[derive(Debug, Clone, Serialize, Deserialize)]
492pub struct ObjectType {
493    pub members: Vec<ObjectTypeMember>,
494}
495
496/// Object type member
497#[derive(Debug, Clone, Serialize, Deserialize)]
498pub enum ObjectTypeMember {
499    Property(PropertySignature),
500    Method(MethodSignature),
501    Index(IndexSignature),
502    Call(CallSignature),
503    Construct(ConstructSignature),
504}
505
506/// Property signature
507#[derive(Debug, Clone, Serialize, Deserialize)]
508pub struct PropertySignature {
509    pub name: String,
510    pub optional: bool,
511    pub type_: Option<Type>,
512    pub readonly: bool,
513}
514
515/// Method signature
516#[derive(Debug, Clone, Serialize, Deserialize)]
517pub struct MethodSignature {
518    pub name: String,
519    pub optional: bool,
520    pub type_parameters: Vec<TypeParameter>,
521    pub parameters: Vec<Parameter>,
522    pub return_type: Option<Type>,
523}
524
525/// Index signature
526#[derive(Debug, Clone, Serialize, Deserialize)]
527pub struct IndexSignature {
528    pub parameter: Box<Parameter>,
529    pub type_: Type,
530    pub readonly: bool,
531}
532
533/// Call signature
534#[derive(Debug, Clone, Serialize, Deserialize)]
535pub struct CallSignature {
536    pub type_parameters: Vec<TypeParameter>,
537    pub parameters: Vec<Parameter>,
538    pub return_type: Option<Type>,
539}
540
541/// Construct signature
542#[derive(Debug, Clone, Serialize, Deserialize)]
543pub struct ConstructSignature {
544    pub type_parameters: Vec<TypeParameter>,
545    pub parameters: Vec<Parameter>,
546    pub return_type: Option<Type>,
547}
548
549/// Mapped type
550#[derive(Debug, Clone, Serialize, Deserialize)]
551pub struct MappedType {
552    pub type_parameter: Box<TypeParameter>,
553    pub constraint: Option<Box<Type>>,
554    pub name_type: Option<Box<Type>>,
555    pub type_: Box<Type>,
556    pub readonly: Option<bool>,
557    pub optional: Option<bool>,
558}
559
560/// Conditional type
561#[derive(Debug, Clone, Serialize, Deserialize)]
562pub struct ConditionalType {
563    pub check_type: Box<Type>,
564    pub extends_type: Box<Type>,
565    pub true_type: Box<Type>,
566    pub false_type: Box<Type>,
567}
568
569/// Template literal type
570#[derive(Debug, Clone, Serialize, Deserialize)]
571pub struct TemplateLiteralType {
572    pub head: String,
573    pub spans: Vec<TemplateLiteralTypeSpan>,
574}
575
576/// Template literal type span
577#[derive(Debug, Clone, Serialize, Deserialize)]
578pub struct TemplateLiteralTypeSpan {
579    pub type_: Type,
580    pub literal: String,
581}
582
583/// Type query
584#[derive(Debug, Clone, Serialize, Deserialize)]
585pub struct TypeQuery {
586    pub expr_name: Box<Expression>,
587}
588
589/// Import type
590#[derive(Debug, Clone, Serialize, Deserialize)]
591pub struct ImportType {
592    pub argument: Box<Type>,
593    pub qualifier: Option<String>,
594    pub type_arguments: Option<Vec<Type>>,
595}
596
597/// Type parameter
598#[derive(Debug, Clone, Serialize, Deserialize)]
599pub struct TypeParameter {
600    pub name: String,
601    pub constraint: Option<Box<Type>>,
602    pub default: Option<Box<Type>>,
603}
604
605/// Parameter
606#[derive(Debug, Clone, Serialize, Deserialize)]
607pub struct Parameter {
608    pub name: String,
609    pub optional: bool,
610    pub type_: Option<Box<Type>>,
611    pub initializer: Option<Expression>,
612    pub rest: bool,
613}
614
615/// Class body
616#[derive(Debug, Clone, Serialize, Deserialize)]
617pub struct ClassBody {
618    pub members: Vec<ClassMember>,
619}
620
621/// Class member
622#[derive(Debug, Clone, Serialize, Deserialize)]
623pub enum ClassMember {
624    Property(PropertyDeclaration),
625    Method(MethodDeclaration),
626    Constructor(ConstructorDeclaration),
627    Getter(GetterDeclaration),
628    Setter(SetterDeclaration),
629    Index(IndexSignature),
630}
631
632/// Property declaration
633#[derive(Debug, Clone, Serialize, Deserialize)]
634pub struct PropertyDeclaration {
635    pub name: String,
636    pub optional: bool,
637    pub type_: Option<Type>,
638    pub initializer: Option<Expression>,
639    pub modifiers: Vec<Modifier>,
640}
641
642/// Method declaration
643#[derive(Debug, Clone, Serialize, Deserialize)]
644pub struct MethodDeclaration {
645    pub name: String,
646    pub optional: bool,
647    pub type_parameters: Vec<TypeParameter>,
648    pub parameters: Vec<Parameter>,
649    pub return_type: Option<Type>,
650    pub body: Option<Statement>,
651    pub modifiers: Vec<Modifier>,
652}
653
654/// Constructor declaration
655#[derive(Debug, Clone, Serialize, Deserialize)]
656pub struct ConstructorDeclaration {
657    pub parameters: Vec<Parameter>,
658    pub body: Option<Statement>,
659    pub modifiers: Vec<Modifier>,
660}
661
662/// Getter declaration
663#[derive(Debug, Clone, Serialize, Deserialize)]
664pub struct GetterDeclaration {
665    pub name: String,
666    pub type_: Option<Type>,
667    pub body: Option<Statement>,
668    pub modifiers: Vec<Modifier>,
669}
670
671/// Setter declaration
672#[derive(Debug, Clone, Serialize, Deserialize)]
673pub struct SetterDeclaration {
674    pub name: String,
675    pub parameter: Parameter,
676    pub body: Option<Statement>,
677    pub modifiers: Vec<Modifier>,
678}
679
680/// Interface body
681#[derive(Debug, Clone, Serialize, Deserialize)]
682pub struct InterfaceBody {
683    pub members: Vec<ObjectTypeMember>,
684}
685
686/// Enum member
687#[derive(Debug, Clone, Serialize, Deserialize)]
688pub struct EnumMember {
689    pub name: String,
690    pub initializer: Option<Expression>,
691}
692
693/// Import specifier
694#[derive(Debug, Clone, Serialize, Deserialize)]
695pub enum ImportSpecifier {
696    Named(NamedImportSpecifier),
697    Default(DefaultImportSpecifier),
698    Namespace(NamespaceImportSpecifier),
699}
700
701/// Named import specifier
702#[derive(Debug, Clone, Serialize, Deserialize)]
703pub struct NamedImportSpecifier {
704    pub name: String,
705    pub imported: String,
706}
707
708/// Default import specifier
709#[derive(Debug, Clone, Serialize, Deserialize)]
710pub struct DefaultImportSpecifier {
711    pub name: String,
712}
713
714/// Namespace import specifier
715#[derive(Debug, Clone, Serialize, Deserialize)]
716pub struct NamespaceImportSpecifier {
717    pub name: String,
718}
719
720/// Catch clause
721#[derive(Debug, Clone, Serialize, Deserialize)]
722pub struct CatchClause {
723    pub parameter: Option<Parameter>,
724    pub body: Box<Statement>,
725}
726
727/// Switch case
728#[derive(Debug, Clone, Serialize, Deserialize)]
729pub struct SwitchCase {
730    pub expression: Option<Expression>,
731    pub statements: Vec<Statement>,
732}
733
734/// Modifier
735#[derive(Debug, Clone, Serialize, Deserialize)]
736pub enum Modifier {
737    Public,
738    Private,
739    Protected,
740    Static,
741    Readonly,
742    Abstract,
743    Async,
744    Override,
745}
746
747/// Source location information
748#[derive(Debug, Clone, Serialize, Deserialize)]
749pub struct SourceLocation {
750    pub start: Position,
751    pub end: Position,
752}
753
754/// Position in source code
755#[derive(Debug, Clone, Serialize, Deserialize)]
756pub struct Position {
757    pub line: usize,
758    pub column: usize,
759    pub offset: usize,
760}
TypeScript_Rust_Compiler/ast.rs

TypeScript_Rust_Compiler/
ast.rs
