Mercurial > python-compiler.rs

comparison src/ast_dump.rs @ 54:ad2453a55820

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Refactor all Vec<T> -> Vec<String> functions into a single one.
author Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
date Sun, 12 Jun 2016 02:17:23 +0100
parents 1a815946c2e5
children 32c78b275d5a
comparison
equal deleted inserted replaced
53:1a815946c2e5 54:ad2453a55820
1 use python_ast::{Module, stmt, expr, boolop, operator, unaryop, cmpop, arguments, arg, keyword, comprehension}; 1 use python_ast::{Module, stmt, expr, boolop, operator, unaryop, cmpop, arguments, arg, keyword, comprehension};
2 2
3 use std::iter; 3 use std::iter;
4
5 trait to_string_able {
6 fn to_string(&self) -> String;
7 }
4 8
5 impl boolop { 9 impl boolop {
6 fn to_string(&self) -> &'static str { 10 fn to_string(&self) -> &'static str {
7 match *self { 11 match *self {
8 boolop::And => " and ", 12 boolop::And => " and ",
57 cmpop::NotIn => "not in", 61 cmpop::NotIn => "not in",
58 } 62 }
59 } 63 }
60 } 64 }
61 65
62 fn args_to_strings(args: Vec<expr>) -> Vec<String> { 66 fn vec_to_strings_vec<T: to_string_able>(values: Vec<T>) -> Vec<String> {
63 let mut arguments = vec!(); 67 let mut vector = vec!();
64 for arg in args { 68 for value in values {
65 arguments.push(arg.to_string()); 69 vector.push(value.to_string());
66 } 70 }
67 arguments 71 vector
68 } 72 }
69 73
70 fn args_to_string(args: Vec<expr>) -> String { 74 impl to_string_able for keyword {
71 let mut arguments = vec!();
72 for arg in args {
73 arguments.push(arg.to_string());
74 }
75 arguments.join(", ")
76 }
77
78 impl keyword {
79 fn to_string(&self) -> String { 75 fn to_string(&self) -> String {
80 match self.arg.clone() { 76 match self.arg.clone() {
81 Some(arg) => format!("{}={}", arg, self.value.to_string()), 77 Some(arg) => format!("{}={}", arg, self.value.to_string()),
82 None => format!("**{}", self.value.to_string()) 78 None => format!("**{}", self.value.to_string())
83 } 79 }
84 } 80 }
85 }
86
87 fn kwargs_to_strings(kwargs: Vec<keyword>) -> Vec<String> {
88 let mut arguments = vec!();
89 for kwarg in kwargs {
90 arguments.push(kwarg.to_string());
91 }
92 arguments
93 }
94
95 fn arguments_to_string(args: arguments) -> String {
96 let mut arguments = vec!();
97 for arg in args.args {
98 arguments.push(arg.arg);
99 }
100 arguments.join(", ")
101 } 81 }
102 82
103 fn statements_to_string(indent: usize, body: Vec<stmt>) -> String { 83 fn statements_to_string(indent: usize, body: Vec<stmt>) -> String {
104 let mut statements = vec!(); 84 let mut statements = vec!();
105 for statement in body { 85 for statement in body {
125 result.push(format!("if {}", if_.to_string())) 105 result.push(format!("if {}", if_.to_string()))
126 } 106 }
127 } 107 }
128 result.join(" ") 108 result.join(" ")
129 } 109 }
130 impl expr { 110
111 impl to_string_able for expr {
131 fn to_string(&self) -> String { 112 fn to_string(&self) -> String {
132 match self.clone() { 113 match self.clone() {
133 expr::BoolOp(op, values) => { 114 expr::BoolOp(op, values) => {
134 let mut data = vec!(); 115 let mut data = vec!();
135 for value in values { 116 for value in values {
160 141
161 arguments.join(" ") 142 arguments.join(" ")
162 }), 143 }),
163 expr::Call(func, args, keywords) => format!("{}({})", func.to_string(), { 144 expr::Call(func, args, keywords) => format!("{}({})", func.to_string(), {
164 let mut arguments = vec!(); 145 let mut arguments = vec!();
165 let args = args_to_strings(args); 146 let args = vec_to_strings_vec(args);
166 let keywords = kwargs_to_strings(keywords); 147 let keywords = vec_to_strings_vec(keywords);
167 arguments.extend(args); 148 arguments.extend(args);
168 arguments.extend(keywords); 149 arguments.extend(keywords);
169 arguments.join(", ") 150 arguments.join(", ")
170 }), 151 }),
171 expr::Num(n) => format!("{}", n), 152 expr::Num(n) => format!("{}", n),
172 expr::Str(s) => format!("\"{}\"", s), 153 expr::Str(s) => format!("\"{}\"", s),
173 expr::NameConstant(name) => format!("{}", name), 154 expr::NameConstant(name) => format!("{}", name),
174 expr::Attribute(value, attr, ctx) => format!("{}.{}", value.to_string(), attr), 155 expr::Attribute(value, attr, ctx) => format!("{}.{}", value.to_string(), attr),
175 expr::Name(name, ctx) => format!("{}", name), 156 expr::Name(name, ctx) => format!("{}", name),
176 expr::List(elts, ctx) => format!("[{}]", args_to_string(elts)), 157 expr::List(elts, ctx) => format!("[{}]", vec_to_strings_vec(elts).join(", ")),
177 expr::ListComp(elt, generators) => format!("[{} {}]", elt.to_string(), generators_to_string(generators)), 158 expr::ListComp(elt, generators) => format!("[{} {}]", elt.to_string(), generators_to_string(generators)),
178 expr::DictComp(key, value, generators) => format!("{{{}: {} {}}}", key.to_string(), value.to_string(), generators_to_string(generators)), 159 expr::DictComp(key, value, generators) => format!("{{{}: {} {}}}", key.to_string(), value.to_string(), generators_to_string(generators)),
179 expr::Tuple(elts, ctx) => format!("({})", args_to_string(elts)), 160 expr::Tuple(elts, ctx) => format!("({})", vec_to_strings_vec(elts).join(", ")),
180 expr::Ellipsis => format!("..."), 161 expr::Ellipsis => format!("..."),
181 } 162 }
182 } 163 }
183 } 164 }
184 165
185 impl arguments { 166 impl to_string_able for arguments {
186 fn to_string(&self) -> String { 167 fn to_string(&self) -> String {
187 let mut args = vec!(); 168 let mut args = vec!();
188 for arg in self.args.clone() { 169 for arg in self.args.clone() {
189 args.push(arg.arg); 170 args.push(arg.arg);
190 } 171 }
198 179
199 impl stmt { 180 impl stmt {
200 fn to_string(&self, indent: usize) -> String { 181 fn to_string(&self, indent: usize) -> String {
201 let current_indent = make_indent(indent); 182 let current_indent = make_indent(indent);
202 match self.clone() { 183 match self.clone() {
203 stmt::ClassDef(name, bases, keywords, body, decorator_list) => format!("{}class {}({}):\n{}", current_indent, name, args_to_string(bases), statements_to_string(indent, body)), 184 stmt::ClassDef(name, bases, keywords, body, decorator_list) => format!("{}class {}({}):\n{}", current_indent, name, vec_to_strings_vec(bases).join(", "), statements_to_string(indent, body)),
204 stmt::FunctionDef(name, arguments, body, decorator_list, returns) => format!("{}def {}({}):\n{}", current_indent, name, arguments_to_string(arguments), statements_to_string(indent, body)), 185 stmt::FunctionDef(name, arguments, body, decorator_list, returns) => format!("{}def {}({}):\n{}", current_indent, name, arguments.to_string(), statements_to_string(indent, body)),
205 stmt::Global(names) => format!("{}global {}", current_indent, names.join(", ")), 186 stmt::Global(names) => format!("{}global {}", current_indent, names.join(", ")),
206 stmt::Nonlocal(names) => format!("{}nonlocal {}", current_indent, names.join(", ")), 187 stmt::Nonlocal(names) => format!("{}nonlocal {}", current_indent, names.join(", ")),
207 stmt::If(test, body, orelse) => format!("{}if {}:\n{}", current_indent, test.to_string(), if_else_statements_to_string(indent, body, orelse)), 188 stmt::If(test, body, orelse) => format!("{}if {}:\n{}", current_indent, test.to_string(), if_else_statements_to_string(indent, body, orelse)),
208 stmt::While(test, body, orelse) => format!("{}while {}:\n{}", current_indent, test.to_string(), if_else_statements_to_string(indent, body, orelse)), 189 stmt::While(test, body, orelse) => format!("{}while {}:\n{}", current_indent, test.to_string(), if_else_statements_to_string(indent, body, orelse)),
209 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)), 190 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)),
210 stmt::Assign(targets, value) => format!("{}{} = {}", current_indent, args_to_string(targets), value.to_string()), 191 stmt::Assign(targets, value) => format!("{}{} = {}", current_indent, vec_to_strings_vec(targets).join(", "), value.to_string()),
211 stmt::AugAssign(target, op, value) => format!("{}{} {}= {}", current_indent, target.to_string(), op.to_string(), value.to_string()), 192 stmt::AugAssign(target, op, value) => format!("{}{} {}= {}", current_indent, target.to_string(), op.to_string(), value.to_string()),
212 stmt::Return(expr) => format!("{}return{}", current_indent, match expr { 193 stmt::Return(expr) => format!("{}return{}", current_indent, match expr {
213 Some(expr) => format!(" {}", expr.to_string()), 194 Some(expr) => format!(" {}", expr.to_string()),
214 None => "".to_string() 195 None => "".to_string()
215 }), 196 }),
245 } 226 }
246 names_.join(", ") 227 names_.join(", ")
247 }), 228 }),
248 stmt::Expr(expr) => format!("{}{}", current_indent, expr.to_string()), 229 stmt::Expr(expr) => format!("{}{}", current_indent, expr.to_string()),
249 stmt::Break => format!("{}break", current_indent), 230 stmt::Break => format!("{}break", current_indent),
250 stmt::Delete(targets) => format!("{}del {}", current_indent, args_to_string(targets)), 231 stmt::Delete(targets) => format!("{}del {}", current_indent, vec_to_strings_vec(targets).join(", ")),
251 stmt::Pass => format!("{}pass", current_indent), 232 stmt::Pass => format!("{}pass", current_indent),
252 stmt::Continue => format!("{}continue", current_indent) 233 stmt::Continue => format!("{}continue", current_indent)
253 } 234 }
254 } 235 }
255 } 236 }