oak_julia/ast/
mod.rs

1/// Python AST 根节
2pub type JuliaAst = ModuleNode;
3
4/// 模块节点
5#[derive(Debug, Clone, PartialEq)]
6pub struct ModuleNode {
7    pub statements: Vec<StmtKind>,
8}
9
10/// Python 语句种类
11#[derive(Debug, Clone, PartialEq)]
12pub enum StmtKind {
13    /// 函数定义
14    FunctionDef(FunctionDefNode),
15    /// 异步函数定义
16    AsyncFunctionDef(AsyncFunctionDefNode),
17    /// 类定
18    ClassDef(ClassDefNode),
19    /// 返回语句
20    Return(Option<Box<ExprKind>>),
21    /// 删除语句
22    Delete(Vec<ExprKind>),
23    /// 赋值语
24    Assign(AssignNode),
25    /// 增强赋值语
26    AugAssign(AugAssignNode),
27    /// 注解赋值语
28    AnnAssign(AnnAssignNode),
29    /// For 循环
30    For(ForNode),
31    /// 异步 For 循环
32    AsyncFor(AsyncForNode),
33    /// While 循环
34    While(WhileNode),
35    /// If 语句
36    If(IfNode),
37    /// With 语句
38    With(WithNode),
39    /// 异步 With 语句
40    AsyncWith(AsyncWithNode),
41    /// Raise 语句
42    Raise(RaiseNode),
43    /// Try 语句
44    Try(TryNode),
45    /// Assert 语句
46    Assert(AssertNode),
47    /// Import 语句
48    Import(ImportNode),
49    /// ImportFrom 语句
50    ImportFrom(ImportFromNode),
51    /// Global 语句
52    Global(Vec<String>),
53    /// Nonlocal 语句
54    Nonlocal(Vec<String>),
55    /// 表达式语
56    Expr(ExprKind),
57    /// Pass 语句
58    Pass,
59    /// Break 语句
60    Break,
61    /// Continue 语句
62    Continue,
63}
64
65/// Python 表达式种
66#[derive(Debug, Clone, PartialEq)]
67pub enum ExprKind {
68    /// 布尔操作
69    BoolOp(BoolOpNode),
70    /// 命名表达(walrus operator)
71    NamedExpr(NamedExprNode),
72    /// 二元操作
73    BinOp(BinOpNode),
74    /// 一元操
75    UnaryOp(UnaryOpNode),
76    /// Lambda 表达
77    Lambda(LambdaNode),
78    /// 条件表达
79    IfExp(IfExpNode),
80    /// 字典表达
81    Dict(DictNode),
82    /// 集合表达
83    Set(SetNode),
84    /// 列表推导
85    ListComp(ListCompNode),
86    /// 集合推导
87    SetComp(SetCompNode),
88    /// 字典推导
89    DictComp(DictCompNode),
90    /// 生成器表达式
91    GeneratorExp(GeneratorExpNode),
92    /// Await 表达
93    Await(Box<ExprKind>),
94    /// Yield 表达
95    Yield(Option<Box<ExprKind>>),
96    /// YieldFrom 表达
97    YieldFrom(Box<ExprKind>),
98    /// 比较表达
99    Compare(CompareNode),
100    /// 函数调用
101    Call(CallNode),
102    /// 格式化字符串
103    FormattedValue(FormattedValueNode),
104    /// 连接字符
105    JoinedStr(Vec<ExprKind>),
106    /// 常量
107    Constant(ConstantNode),
108    /// 属性访
109    Attribute(AttributeNode),
110    /// 下标访问
111    Subscript(SubscriptNode),
112    /// 星号表达
113    Starred(Box<ExprKind>),
114    /// 名称
115    Name(NameNode),
116    /// 列表
117    List(ListNode),
118    /// 元组
119    Tuple(TupleNode),
120    /// 切片
121    Slice(SliceNode),
122}
123
124/// 函数定义节点
125#[derive(Debug, Clone, PartialEq)]
126pub struct FunctionDefNode {
127    pub name: String,
128    pub args: ArgumentsNode,
129    pub body: Vec<StmtKind>,
130    pub decorator_list: Vec<ExprKind>,
131    pub returns: Option<Box<ExprKind>>,
132    pub type_comment: Option<String>,
133}
134
135/// 异步函数定义节点
136#[derive(Debug, Clone, PartialEq)]
137pub struct AsyncFunctionDefNode {
138    pub name: String,
139    pub args: ArgumentsNode,
140    pub body: Vec<StmtKind>,
141    pub decorator_list: Vec<ExprKind>,
142    pub returns: Option<Box<ExprKind>>,
143    pub type_comment: Option<String>,
144}
145
146/// 类定义节
147#[derive(Debug, Clone, PartialEq)]
148pub struct ClassDefNode {
149    pub name: String,
150    pub bases: Vec<ExprKind>,
151    pub keywords: Vec<KeywordNode>,
152    pub body: Vec<StmtKind>,
153    pub decorator_list: Vec<ExprKind>,
154}
155
156/// 参数节点
157#[derive(Debug, Clone, PartialEq)]
158pub struct ArgumentsNode {
159    pub posonlyargs: Vec<ArgNode>,
160    pub args: Vec<ArgNode>,
161    pub vararg: Option<ArgNode>,
162    pub kwonlyargs: Vec<ArgNode>,
163    pub kw_defaults: Vec<Option<ExprKind>>,
164    pub kwarg: Option<ArgNode>,
165    pub defaults: Vec<ExprKind>,
166}
167
168/// 参数节点
169#[derive(Debug, Clone, PartialEq)]
170pub struct ArgNode {
171    pub arg: String,
172    pub annotation: Option<Box<ExprKind>>,
173    pub type_comment: Option<String>,
174}
175
176/// 关键字参数节
177#[derive(Debug, Clone, PartialEq)]
178pub struct KeywordNode {
179    pub arg: Option<String>,
180    pub value: ExprKind,
181}
182
183/// 赋值节
184#[derive(Debug, Clone, PartialEq)]
185pub struct AssignNode {
186    pub targets: Vec<ExprKind>,
187    pub value: ExprKind,
188    pub type_comment: Option<String>,
189}
190
191/// 增强赋值节
192#[derive(Debug, Clone, PartialEq)]
193pub struct AugAssignNode {
194    pub target: ExprKind,
195    pub op: BinaryOperator,
196    pub value: ExprKind,
197}
198
199/// 注解赋值节
200#[derive(Debug, Clone, PartialEq)]
201pub struct AnnAssignNode {
202    pub target: ExprKind,
203    pub annotation: ExprKind,
204    pub value: Option<Box<ExprKind>>,
205    pub simple: bool,
206}
207
208/// For 循环节点
209#[derive(Debug, Clone, PartialEq)]
210pub struct ForNode {
211    pub target: ExprKind,
212    pub iter: ExprKind,
213    pub body: Vec<StmtKind>,
214    pub orelse: Vec<StmtKind>,
215    pub type_comment: Option<String>,
216}
217
218/// 异步 For 循环节点
219#[derive(Debug, Clone, PartialEq)]
220pub struct AsyncForNode {
221    pub target: ExprKind,
222    pub iter: ExprKind,
223    pub body: Vec<StmtKind>,
224    pub orelse: Vec<StmtKind>,
225    pub type_comment: Option<String>,
226}
227
228/// While 循环节点
229#[derive(Debug, Clone, PartialEq)]
230pub struct WhileNode {
231    pub test: ExprKind,
232    pub body: Vec<StmtKind>,
233    pub orelse: Vec<StmtKind>,
234}
235
236/// If 语句节点
237#[derive(Debug, Clone, PartialEq)]
238pub struct IfNode {
239    pub test: ExprKind,
240    pub body: Vec<StmtKind>,
241    pub orelse: Vec<StmtKind>,
242}
243
244/// With 语句节点
245#[derive(Debug, Clone, PartialEq)]
246pub struct WithNode {
247    pub items: Vec<WithItemNode>,
248    pub body: Vec<StmtKind>,
249    pub type_comment: Option<String>,
250}
251
252/// 异步 With 语句节点
253#[derive(Debug, Clone, PartialEq)]
254pub struct AsyncWithNode {
255    pub items: Vec<WithItemNode>,
256    pub body: Vec<StmtKind>,
257    pub type_comment: Option<String>,
258}
259
260/// With 项节
261#[derive(Debug, Clone, PartialEq)]
262pub struct WithItemNode {
263    pub context_expr: ExprKind,
264    pub optional_vars: Option<Box<ExprKind>>,
265}
266
267/// Raise 语句节点
268#[derive(Debug, Clone, PartialEq)]
269pub struct RaiseNode {
270    pub exc: Option<Box<ExprKind>>,
271    pub cause: Option<Box<ExprKind>>,
272}
273
274/// Try 语句节点
275#[derive(Debug, Clone, PartialEq)]
276pub struct TryNode {
277    pub body: Vec<StmtKind>,
278    pub handlers: Vec<ExceptHandlerNode>,
279    pub orelse: Vec<StmtKind>,
280    pub finalbody: Vec<StmtKind>,
281}
282
283/// 异常处理器节
284#[derive(Debug, Clone, PartialEq)]
285pub struct ExceptHandlerNode {
286    pub type_: Option<Box<ExprKind>>,
287    pub name: Option<String>,
288    pub body: Vec<StmtKind>,
289}
290
291/// Assert 语句节点
292#[derive(Debug, Clone, PartialEq)]
293pub struct AssertNode {
294    pub test: ExprKind,
295    pub msg: Option<Box<ExprKind>>,
296}
297
298/// Import 语句节点
299#[derive(Debug, Clone, PartialEq)]
300pub struct ImportNode {
301    pub names: Vec<AliasNode>,
302}
303
304/// ImportFrom 语句节点
305#[derive(Debug, Clone, PartialEq)]
306pub struct ImportFromNode {
307    pub module: Option<String>,
308    pub names: Vec<AliasNode>,
309    pub level: Option<i32>,
310}
311
312/// 别名节点
313#[derive(Debug, Clone, PartialEq)]
314pub struct AliasNode {
315    pub name: String,
316    pub asname: Option<String>,
317}
318
319/// 布尔操作节点
320#[derive(Debug, Clone, PartialEq)]
321pub struct BoolOpNode {
322    pub op: BooleanOperator,
323    pub values: Vec<ExprKind>,
324}
325
326/// 命名表达式节
327#[derive(Debug, Clone, PartialEq)]
328pub struct NamedExprNode {
329    pub target: Box<ExprKind>,
330    pub value: Box<ExprKind>,
331}
332
333/// 二元操作节点
334#[derive(Debug, Clone, PartialEq)]
335pub struct BinOpNode {
336    pub left: Box<ExprKind>,
337    pub op: BinaryOperator,
338    pub right: Box<ExprKind>,
339}
340
341/// 一元操作节
342#[derive(Debug, Clone, PartialEq)]
343pub struct UnaryOpNode {
344    pub op: UnaryOperator,
345    pub operand: Box<ExprKind>,
346}
347
348/// Lambda 节点
349#[derive(Debug, Clone, PartialEq)]
350pub struct LambdaNode {
351    pub args: ArgumentsNode,
352    pub body: Box<ExprKind>,
353}
354
355/// 条件表达式节
356#[derive(Debug, Clone, PartialEq)]
357pub struct IfExpNode {
358    pub test: Box<ExprKind>,
359    pub body: Box<ExprKind>,
360    pub orelse: Box<ExprKind>,
361}
362
363/// 字典节点
364#[derive(Debug, Clone, PartialEq)]
365pub struct DictNode {
366    pub keys: Vec<Option<ExprKind>>,
367    pub values: Vec<ExprKind>,
368}
369
370/// 集合节点
371#[derive(Debug, Clone, PartialEq)]
372pub struct SetNode {
373    pub elts: Vec<ExprKind>,
374}
375
376/// 列表推导式节
377#[derive(Debug, Clone, PartialEq)]
378pub struct ListCompNode {
379    pub elt: Box<ExprKind>,
380    pub generators: Vec<ComprehensionNode>,
381}
382
383/// 集合推导式节
384#[derive(Debug, Clone, PartialEq)]
385pub struct SetCompNode {
386    pub elt: Box<ExprKind>,
387    pub generators: Vec<ComprehensionNode>,
388}
389
390/// 字典推导式节
391#[derive(Debug, Clone, PartialEq)]
392pub struct DictCompNode {
393    pub key: Box<ExprKind>,
394    pub value: Box<ExprKind>,
395    pub generators: Vec<ComprehensionNode>,
396}
397
398/// 生成器表达式节点
399#[derive(Debug, Clone, PartialEq)]
400pub struct GeneratorExpNode {
401    pub elt: Box<ExprKind>,
402    pub generators: Vec<ComprehensionNode>,
403}
404
405/// 推导式节
406#[derive(Debug, Clone, PartialEq)]
407pub struct ComprehensionNode {
408    pub target: ExprKind,
409    pub iter: ExprKind,
410    pub ifs: Vec<ExprKind>,
411    pub is_async: bool,
412}
413
414/// 比较节点
415#[derive(Debug, Clone, PartialEq)]
416pub struct CompareNode {
417    pub left: Box<ExprKind>,
418    pub ops: Vec<ComparisonOperator>,
419    pub comparators: Vec<ExprKind>,
420}
421
422/// 函数调用节点
423#[derive(Debug, Clone, PartialEq)]
424pub struct CallNode {
425    pub func: Box<ExprKind>,
426    pub args: Vec<ExprKind>,
427    pub keywords: Vec<KeywordNode>,
428}
429
430/// 格式化值节
431#[derive(Debug, Clone, PartialEq)]
432pub struct FormattedValueNode {
433    pub value: Box<ExprKind>,
434    pub conversion: Option<i32>,
435    pub format_spec: Option<Box<ExprKind>>,
436}
437
438/// 常量节点
439#[derive(Debug, Clone, PartialEq)]
440pub struct ConstantNode {
441    pub value: ConstantValue,
442    pub kind: Option<String>,
443}
444
445/// 常量
446#[derive(Debug, Clone, PartialEq)]
447pub enum ConstantValue {
448    None,
449    Bool(bool),
450    Int(i64),
451    Float(f64),
452    Complex { real: f64, imag: f64 },
453    Str(String),
454    Bytes(Vec<u8>),
455    Ellipsis,
456}
457
458/// 属性访问节
459#[derive(Debug, Clone, PartialEq)]
460pub struct AttributeNode {
461    pub value: Box<ExprKind>,
462    pub attr: String,
463}
464
465/// 下标访问节点
466#[derive(Debug, Clone, PartialEq)]
467pub struct SubscriptNode {
468    pub value: Box<ExprKind>,
469    pub slice: Box<ExprKind>,
470}
471
472/// 名称节点
473#[derive(Debug, Clone, PartialEq)]
474pub struct NameNode {
475    pub id: String,
476}
477
478/// 列表节点
479#[derive(Debug, Clone, PartialEq)]
480pub struct ListNode {
481    pub elts: Vec<ExprKind>,
482}
483
484/// 元组节点
485#[derive(Debug, Clone, PartialEq)]
486pub struct TupleNode {
487    pub elts: Vec<ExprKind>,
488}
489
490/// 切片节点
491#[derive(Debug, Clone, PartialEq)]
492pub struct SliceNode {
493    pub lower: Option<Box<ExprKind>>,
494    pub upper: Option<Box<ExprKind>>,
495    pub step: Option<Box<ExprKind>>,
496}
497
498/// 布尔操作
499#[derive(Debug, Clone, PartialEq)]
500pub enum BooleanOperator {
501    And,
502    Or,
503}
504
505/// 二元操作
506#[derive(Debug, Clone, PartialEq)]
507pub enum BinaryOperator {
508    Add,
509    Sub,
510    Mult,
511    MatMult,
512    Div,
513    Mod,
514    Pow,
515    LShift,
516    RShift,
517    BitOr,
518    BitXor,
519    BitAnd,
520    FloorDiv,
521}
522
523/// 一元操作符
524#[derive(Debug, Clone, PartialEq)]
525pub enum UnaryOperator {
526    Invert,
527    Not,
528    UAdd,
529    USub,
530}
531
532/// 比较操作
533#[derive(Debug, Clone, PartialEq)]
534pub enum ComparisonOperator {
535    Eq,
536    NotEq,
537    Lt,
538    LtE,
539    Gt,
540    GtE,
541    Is,
542    IsNot,
543    In,
544    NotIn,
545}
546
547// 实现 AstNode trait
548impl ModuleNode {
549    pub fn kind(&self) -> &'static str {
550        "Module"
551    }
552}
553
554/// Python AST 访问trait
555pub trait JuliaAstVisitor {
556    fn visit_module(&mut self, node: &ModuleNode);
557    fn visit_stmt(&mut self, stmt: &StmtKind);
558    fn visit_expr(&mut self, expr: &ExprKind);
559    fn visit_function_def(&mut self, node: &FunctionDefNode);
560    fn visit_class_def(&mut self, node: &ClassDefNode);
561    fn visit_call(&mut self, node: &CallNode);
562    fn visit_name(&mut self, node: &NameNode);
563    fn visit_constant(&mut self, node: &ConstantNode);
564}
oak_julia/ast/mod.rs

oak_julia/ast/
mod.rs
