Mercurial > python-compiler.rs

comparison src/ast_dump.rs @ 13:38b0d63697b1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import the full AST grammar from CPython 3.5.
author Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
date Thu, 02 Jun 2016 05:33:23 +0100
parents 94ff501bf336
children 719a27f1c1c7
comparison
equal deleted inserted replaced
12:0e96c5bc401d 13:38b0d63697b1
1 use python_ast::{Module, Statement, Expr, BinOp, UnaryOp}; 1 use python_ast::{Module, stmt, expr, boolop, operator, unaryop, cmpop, arguments, arg, keyword};
2 2
3 use std::iter; 3 use std::iter;
4 4
5 impl UnaryOp { 5 impl boolop {
6 fn to_string(&self) -> &'static str { 6 fn to_string(&self) -> &'static str {
7 match *self { 7 match *self {
8 UnaryOp::UAdd => "+", 8 boolop::And => "and",
9 UnaryOp::USub => "-", 9 boolop::Or => "or"
10 UnaryOp::Error => "BinOp::Error"
11 } 10 }
12 } 11 }
13 } 12 }
14 13
15 impl BinOp { 14 impl operator {
16 fn to_string(&self) -> &'static str { 15 fn to_string(&self) -> &'static str {
17 match *self { 16 match *self {
18 BinOp::BinAdd => "+", 17 operator::Add => "+",
19 BinOp::BinMult => "*", 18 operator::Sub => "-",
20 BinOp::BinEq => "==", 19 operator::Mult => "*",
21 BinOp::BinLt => "<", 20 operator::MatMult => "@",
22 BinOp::BinGt => ">", 21 operator::Div => "/",
23 BinOp::Sub => "-", 22 operator::Mod => "%",
24 BinOp::Div => "/", 23 operator::Pow => "**",
25 BinOp::Error => "BinOp::Error" 24 operator::LShift => "<<",
25 operator::RShift => ">>",
26 operator::BitOr => "|",
27 operator::BitXor => "^",
28 operator::BitAnd => "&",
29 operator::FloorDiv => "//",
26 } 30 }
27 } 31 }
28 } 32 }
29 33
30 impl Expr { 34 impl unaryop {
35 fn to_string(&self) -> &'static str {
36 match *self {
37 unaryop::Invert => "~",
38 unaryop::Not => "!",
39 unaryop::UAdd => "+",
40 unaryop::USub => "-"
41 }
42 }
43 }
44
45 impl cmpop {
46 fn to_string(&self) -> &'static str {
47 match *self {
48 cmpop::Eq => "==",
49 cmpop::NotEq => "!=",
50 cmpop::Lt => "<",
51 cmpop::LtE => "<=",
52 cmpop::Gt => ">",
53 cmpop::GtE => ">=",
54 cmpop::Is => "is",
55 cmpop::IsNot => "is not",
56 cmpop::In => "in",
57 cmpop::NotIn => "not in",
58 }
59 }
60 }
61
62 fn args_to_string(args: Vec<expr>) -> String {
63 let mut arguments = vec!();
64 for arg in args {
65 arguments.push(arg.to_string());
66 }
67 arguments.join(", ")
68 }
69
70 fn kwargs_to_string(kwargs: Vec<keyword>) -> String {
71 let mut arguments = vec!();
72 for arg in kwargs {
73 match arg.arg {
74 Some(arg) => arguments.push(arg),
75 None => arguments.push("**kwarg".to_string())
76 }
77 }
78 arguments.join(", ")
79 }
80
81 fn arguments_to_string(args: arguments) -> String {
82 let mut arguments = vec!();
83 for arg in args.args {
84 arguments.push(arg.arg);
85 }
86 arguments.join(", ")
87 }
88
89 fn statements_to_string(indent: usize, body: Vec<stmt>) -> String {
90 let mut statements = vec!();
91 for statement in body {
92 statements.push(statement.to_string(indent + 1));
93 }
94 statements.join("\n")
95 }
96
97 fn if_else_statements_to_string(indent: usize, body: Vec<stmt>, orelse: Vec<stmt>) -> String {
98 let body = statements_to_string(indent, body);
99 if orelse.is_empty() {
100 body
101 } else {
102 format!("{}\n{}else:\n{}", body, make_indent(indent), statements_to_string(indent, orelse))
103 }
104 }
105
106 impl expr {
31 fn to_string(&self) -> String { 107 fn to_string(&self) -> String {
32 match self.clone() { 108 match self.clone() {
33 Expr::UnaryOp(op, operand) => format!("{}{}", op.to_string(), operand.to_string()), 109 expr::BoolOp(op, values) => format!("{}({})", op.to_string(), args_to_string(values)),
34 Expr::BinOp(a, op, b) => format!("{} {} {}", a.to_string(), op.to_string(), b.to_string()), 110 expr::BinOp(a, op, b) => format!("{} {} {}", a.to_string(), op.to_string(), b.to_string()),
35 Expr::Compare(left, ops, comparators) => format!("{} {}", left.to_string(), { 111 expr::UnaryOp(op, operand) => format!("{}{}", op.to_string(), operand.to_string()),
112
113 expr::Compare(left, ops, comparators) => format!("{} {}", left.to_string(), {
36 let mut arguments = vec!(); 114 let mut arguments = vec!();
37 115
38 // XXX: wrong order! 116 // XXX: wrong order!
39 for op in ops { 117 for op in ops {
40 arguments.push(op.to_string().to_string()) 118 arguments.push(op.to_string().to_string())
50 } 128 }
51 */ 129 */
52 130
53 arguments.join(" ") 131 arguments.join(" ")
54 }), 132 }),
55 Expr::Call(func, args) => format!("{}({})", func.to_string(), { 133 expr::Call(func, args, keywords) => format!("{}({}{})", func.to_string(), args_to_string(args), kwargs_to_string(keywords)),
56 let mut arguments = vec!(); 134 expr::Num(n) => format!("{}", n),
57 for arg in args { 135 expr::Str(s) => format!("\"{}\"", s),
58 arguments.push(arg.to_string()); 136 expr::NameConstant(name) => format!("{}", name),
59 } 137 expr::Attribute(value, attr, ctx) => format!("{}.{}", value.to_string(), attr),
60 arguments.join(", ") 138 expr::Name(name, ctx) => format!("{}", name),
61 }), 139 expr::List(elts, ctx) => format!("[{}]", args_to_string(elts))
62 Expr::Alias(name, asname) => {
63 match asname {
64 None => format!("{}", name),
65 Some(asname) => format!("{} as {}", name, asname)
66 }
67 }
68 Expr::Attribute(lhs, rhs) => format!("{}.{}", lhs.to_string(), rhs),
69 Expr::Name(name) => format!("{}", name),
70 Expr::NameConstant(name) => format!("{}", name),
71 Expr::Str(s) => format!("\"{}\"", s),
72 Expr::Num(n) => format!("{}", n),
73 Expr::List(elts) => format!("[{}]", {
74 let mut elements = vec!();
75 for elt in elts {
76 elements.push(elt.to_string());
77 }
78 elements.join(", ")
79 }),
80 Expr::Error => "Expr::Error".to_string()
81 } 140 }
82 } 141 }
83 } 142 }
84 143
85 fn make_indent(indent: usize) -> String { 144 impl arguments {
86 let indent: String = iter::repeat(" ").take(indent).collect(); 145 fn to_string(&self) -> String {
87 indent 146 let mut args = vec!();
147 for arg in self.args.clone() {
148 args.push(arg.arg);
149 }
150 args.join(", ")
151 }
88 } 152 }
89 153
90 impl Statement { 154 fn make_indent(indent: usize) -> String {
155 iter::repeat(" ").take(indent).collect()
156 }
157
158 impl stmt {
91 fn to_string(&self, indent: usize) -> String { 159 fn to_string(&self, indent: usize) -> String {
160 let current_indent = make_indent(indent);
92 match self.clone() { 161 match self.clone() {
93 Statement::ClassDef(name, classes, body) => format!("{}def {}({}):\n{}", make_indent(indent), name, { 162 stmt::ClassDef(name, bases, keywords, body, decorator_list) => format!("{}def {}({}):\n{}", current_indent, name, args_to_string(bases), statements_to_string(indent, body)),
94 let mut bases = vec!(); 163 stmt::FunctionDef(name, arguments, body, decorator_list, returns) => format!("{}def {}({}):\n{}", current_indent, name, arguments_to_string(arguments), statements_to_string(indent, body)),
95 for class in classes { 164 stmt::Global(names) => format!("{}global {}", current_indent, names.join(", ")),
96 bases.push(class.to_string()); 165 stmt::If(test, body, orelse) => format!("{}if {}:\n{}", current_indent, test.to_string(), if_else_statements_to_string(indent, body, orelse)),
97 } 166 stmt::While(test, body, orelse) => format!("{}while {}:\n{}", current_indent, test.to_string(), if_else_statements_to_string(indent, body, orelse)),
98 bases.join(", ") 167 stmt::For(target, iter, body, orelse) => format!("{}for {} in {}:\n{}", current_indent, target.to_string(), iter.to_string(), if_else_statements_to_string(indent, body, orelse)),
99 }, { 168 stmt::Assign(targets, value) => format!("{}{} = {}", current_indent, args_to_string(targets), value.to_string()),
100 let mut statements = vec!(); 169 stmt::AugAssign(target, op, value) => format!("{}{} {}= {}", current_indent, target.to_string(), op.to_string(), value.to_string()),
101 for statement in body { 170 stmt::Return(expr) => format!("{}return{}", current_indent, match expr {
102 statements.push(statement.to_string(indent + 1)); 171 Some(expr) => format!(" {}", expr.to_string()),
103 } 172 None => "".to_string()
104 statements.join("\n")
105 }), 173 }),
106 Statement::FunctionDef(name, arguments, body) => format!("{}def {}({}):\n{}", make_indent(indent), name, { 174 stmt::ImportFrom(module, names, level) => format!("{}from {} import {}", current_indent, module.to_string(), {
107 let mut args = vec!(); 175 /*
108 for arg in arguments {
109 args.push(arg.to_string());
110 }
111 args.join(", ")
112 }, {
113 let mut statements = vec!();
114 for statement in body {
115 statements.push(statement.to_string(indent + 1));
116 }
117 statements.join("\n")
118 }),
119 Statement::Global(names) => format!("{}global {}", make_indent(indent), names.join(", ")),
120 Statement::If(test, body, orelse) => format!("{}if {}:\n{}", make_indent(indent), test.to_string(), {
121 let mut statements = vec!();
122 for arg in body {
123 statements.push(arg.to_string(indent + 1));
124 }
125
126 let mut orelse_ = vec!();
127 for arg in orelse {
128 orelse_.push(arg.to_string(indent + 1));
129 }
130
131 if orelse_.is_empty() {
132 statements.join("\n")
133 } else {
134 format!("{}\n{}else:\n{}", statements.join("\n"), make_indent(indent), orelse_.join("\n"))
135 }
136 }),
137 Statement::While(test, body, orelse) => format!("{}while {}:\n{}", make_indent(indent), test.to_string(), {
138 let mut statements = vec!();
139 for arg in body {
140 statements.push(arg.to_string(indent + 1));
141 }
142
143 let mut orelse_ = vec!();
144 for arg in orelse {
145 orelse_.push(arg.to_string(indent + 1));
146 }
147
148 if orelse_.is_empty() {
149 statements.join("\n")
150 } else {
151 format!("{}\n{}else:\n{}", statements.join("\n"), make_indent(indent), orelse_.join("\n"))
152 }
153 }),
154 Statement::For(target, iter, body, orelse) => format!("{}for {} in {}:\n{}", make_indent(indent), target.to_string(), iter.to_string(), {
155 let mut statements = vec!();
156 for arg in body {
157 statements.push(arg.to_string(indent + 1));
158 }
159
160 let mut orelse_ = vec!();
161 for arg in orelse {
162 orelse_.push(arg.to_string(indent + 1));
163 }
164
165 if orelse_.is_empty() {
166 statements.join("\n")
167 } else {
168 format!("{}\n{}else:\n{}", statements.join("\n"), make_indent(indent), orelse_.join("\n"))
169 }
170 }),
171 Statement::Assign(targets, value) => format!("{}{} = {}", make_indent(indent), {
172 let mut exprs = vec!();
173 for target in targets {
174 exprs.push(target.to_string());
175 }
176 exprs.join(", ")
177 }, value.to_string()),
178 Statement::AugAssign(target, op, value) => format!("{}{} {}= {}", make_indent(indent), target.to_string(), op.to_string(), value.to_string()),
179 Statement::Return(expr) => format!("{}return {}", make_indent(indent), expr.to_string()),
180 Statement::ImportFrom(module, names) => format!("{}from {} import {}", make_indent(indent), module.to_string(), {
181 let mut exprs = vec!(); 176 let mut exprs = vec!();
182 for alias in names.iter() { 177 for alias in names.iter() {
183 let alias = alias.to_string(); 178 let alias = alias.to_string();
184 exprs.push(alias); 179 exprs.push(alias);
185 } 180 }
186 exprs.join(", ") 181 exprs.join(", ")
182 */
183 "".to_string()
187 }), 184 }),
188 Statement::Expr(expr) => format!("{}{}", make_indent(indent), expr.to_string()), 185 stmt::Expr(expr) => format!("{}{}", current_indent, expr.to_string()),
189 Statement::Break => format!("{}break", make_indent(indent)), 186 stmt::Break => format!("{}break", current_indent)
190 Statement::Error => format!("{}Statement::Error", make_indent(indent))
191 } 187 }
192 } 188 }
193 } 189 }
194 190
195 #[allow(dead_code)] 191 #[allow(dead_code)]