OLD | NEW |
(Empty) | |
| 1 # copyright 2003-2013 LOGILAB S.A. (Paris, FRANCE), all rights reserved. |
| 2 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr |
| 3 # |
| 4 # This file is part of astroid. |
| 5 # |
| 6 # astroid is free software: you can redistribute it and/or modify it |
| 7 # under the terms of the GNU Lesser General Public License as published by the |
| 8 # Free Software Foundation, either version 2.1 of the License, or (at your |
| 9 # option) any later version. |
| 10 # |
| 11 # astroid is distributed in the hope that it will be useful, but |
| 12 # WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| 13 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License |
| 14 # for more details. |
| 15 # |
| 16 # You should have received a copy of the GNU Lesser General Public License along |
| 17 # with astroid. If not, see <http://www.gnu.org/licenses/>. |
| 18 """this module contains utilities for rebuilding a _ast tree in |
| 19 order to get a single Astroid representation |
| 20 """ |
| 21 |
| 22 import sys |
| 23 from _ast import ( |
| 24 Expr as Discard, Str, |
| 25 # binary operators |
| 26 Add, Div, FloorDiv, Mod, Mult, Pow, Sub, BitAnd, BitOr, BitXor, |
| 27 LShift, RShift, |
| 28 # logical operators |
| 29 And, Or, |
| 30 # unary operators |
| 31 UAdd, USub, Not, Invert, |
| 32 # comparison operators |
| 33 Eq, Gt, GtE, In, Is, IsNot, Lt, LtE, NotEq, NotIn, |
| 34 ) |
| 35 |
| 36 from astroid import nodes as new |
| 37 |
| 38 |
| 39 _BIN_OP_CLASSES = {Add: '+', |
| 40 BitAnd: '&', |
| 41 BitOr: '|', |
| 42 BitXor: '^', |
| 43 Div: '/', |
| 44 FloorDiv: '//', |
| 45 Mod: '%', |
| 46 Mult: '*', |
| 47 Pow: '**', |
| 48 Sub: '-', |
| 49 LShift: '<<', |
| 50 RShift: '>>', |
| 51 } |
| 52 |
| 53 _BOOL_OP_CLASSES = {And: 'and', |
| 54 Or: 'or', |
| 55 } |
| 56 |
| 57 _UNARY_OP_CLASSES = {UAdd: '+', |
| 58 USub: '-', |
| 59 Not: 'not', |
| 60 Invert: '~', |
| 61 } |
| 62 |
| 63 _CMP_OP_CLASSES = {Eq: '==', |
| 64 Gt: '>', |
| 65 GtE: '>=', |
| 66 In: 'in', |
| 67 Is: 'is', |
| 68 IsNot: 'is not', |
| 69 Lt: '<', |
| 70 LtE: '<=', |
| 71 NotEq: '!=', |
| 72 NotIn: 'not in', |
| 73 } |
| 74 |
| 75 CONST_NAME_TRANSFORMS = {'None': None, |
| 76 'True': True, |
| 77 'False': False, |
| 78 } |
| 79 |
| 80 REDIRECT = {'arguments': 'Arguments', |
| 81 'Attribute': 'Getattr', |
| 82 'comprehension': 'Comprehension', |
| 83 'Call': 'CallFunc', |
| 84 'ClassDef': 'Class', |
| 85 "ListCompFor": 'Comprehension', |
| 86 "GenExprFor": 'Comprehension', |
| 87 'excepthandler': 'ExceptHandler', |
| 88 'Expr': 'Discard', |
| 89 'FunctionDef': 'Function', |
| 90 'GeneratorExp': 'GenExpr', |
| 91 'ImportFrom': 'From', |
| 92 'keyword': 'Keyword', |
| 93 'Repr': 'Backquote', |
| 94 } |
| 95 PY3K = sys.version_info >= (3, 0) |
| 96 PY34 = sys.version_info >= (3, 4) |
| 97 |
| 98 def _init_set_doc(node, newnode): |
| 99 newnode.doc = None |
| 100 try: |
| 101 if isinstance(node.body[0], Discard) and isinstance(node.body[0].value,
Str): |
| 102 newnode.doc = node.body[0].value.s |
| 103 node.body = node.body[1:] |
| 104 |
| 105 except IndexError: |
| 106 pass # ast built from scratch |
| 107 |
| 108 def _lineno_parent(oldnode, newnode, parent): |
| 109 newnode.parent = parent |
| 110 newnode.lineno = oldnode.lineno |
| 111 newnode.col_offset = oldnode.col_offset |
| 112 |
| 113 def _set_infos(oldnode, newnode, parent): |
| 114 newnode.parent = parent |
| 115 if hasattr(oldnode, 'lineno'): |
| 116 newnode.lineno = oldnode.lineno |
| 117 if hasattr(oldnode, 'col_offset'): |
| 118 newnode.col_offset = oldnode.col_offset |
| 119 |
| 120 def _create_yield_node(node, parent, rebuilder, factory): |
| 121 newnode = factory() |
| 122 _lineno_parent(node, newnode, parent) |
| 123 if node.value is not None: |
| 124 newnode.value = rebuilder.visit(node.value, newnode) |
| 125 return newnode |
| 126 |
| 127 |
| 128 class TreeRebuilder(object): |
| 129 """Rebuilds the _ast tree to become an Astroid tree""" |
| 130 |
| 131 def __init__(self, manager): |
| 132 self._manager = manager |
| 133 self.asscontext = None |
| 134 self._global_names = [] |
| 135 self._from_nodes = [] |
| 136 self._delayed_assattr = [] |
| 137 self._visit_meths = {} |
| 138 self._transform = manager.transform |
| 139 |
| 140 def visit_module(self, node, modname, modpath, package): |
| 141 """visit a Module node by returning a fresh instance of it""" |
| 142 newnode = new.Module(modname, None) |
| 143 newnode.package = package |
| 144 newnode.parent = None |
| 145 _init_set_doc(node, newnode) |
| 146 newnode.body = [self.visit(child, newnode) for child in node.body] |
| 147 newnode.file = newnode.path = modpath |
| 148 return self._transform(newnode) |
| 149 |
| 150 def visit(self, node, parent): |
| 151 cls = node.__class__ |
| 152 if cls in self._visit_meths: |
| 153 visit_method = self._visit_meths[cls] |
| 154 else: |
| 155 cls_name = cls.__name__ |
| 156 visit_name = 'visit_' + REDIRECT.get(cls_name, cls_name).lower() |
| 157 visit_method = getattr(self, visit_name) |
| 158 self._visit_meths[cls] = visit_method |
| 159 return self._transform(visit_method(node, parent)) |
| 160 |
| 161 def _save_assignment(self, node, name=None): |
| 162 """save assignement situation since node.parent is not available yet""" |
| 163 if self._global_names and node.name in self._global_names[-1]: |
| 164 node.root().set_local(node.name, node) |
| 165 else: |
| 166 node.parent.set_local(node.name, node) |
| 167 |
| 168 |
| 169 def visit_arguments(self, node, parent): |
| 170 """visit a Arguments node by returning a fresh instance of it""" |
| 171 newnode = new.Arguments() |
| 172 newnode.parent = parent |
| 173 self.asscontext = "Ass" |
| 174 newnode.args = [self.visit(child, newnode) for child in node.args] |
| 175 self.asscontext = None |
| 176 newnode.defaults = [self.visit(child, newnode) for child in node.default
s] |
| 177 newnode.kwonlyargs = [] |
| 178 newnode.kw_defaults = [] |
| 179 vararg, kwarg = node.vararg, node.kwarg |
| 180 # change added in 82732 (7c5c678e4164), vararg and kwarg |
| 181 # are instances of `_ast.arg`, not strings |
| 182 if vararg: |
| 183 if PY34: |
| 184 if vararg.annotation: |
| 185 newnode.varargannotation = self.visit(vararg.annotation, |
| 186 newnode) |
| 187 vararg = vararg.arg |
| 188 elif PY3K and node.varargannotation: |
| 189 newnode.varargannotation = self.visit(node.varargannotation, |
| 190 newnode) |
| 191 if kwarg: |
| 192 if PY34: |
| 193 if kwarg.annotation: |
| 194 newnode.kwargannotation = self.visit(kwarg.annotation, |
| 195 newnode) |
| 196 kwarg = kwarg.arg |
| 197 elif PY3K: |
| 198 if node.kwargannotation: |
| 199 newnode.kwargannotation = self.visit(node.kwargannotation, |
| 200 newnode) |
| 201 newnode.vararg = vararg |
| 202 newnode.kwarg = kwarg |
| 203 # save argument names in locals: |
| 204 if vararg: |
| 205 newnode.parent.set_local(vararg, newnode) |
| 206 if kwarg: |
| 207 newnode.parent.set_local(kwarg, newnode) |
| 208 return newnode |
| 209 |
| 210 def visit_assattr(self, node, parent): |
| 211 """visit a AssAttr node by returning a fresh instance of it""" |
| 212 assc, self.asscontext = self.asscontext, None |
| 213 newnode = new.AssAttr() |
| 214 _lineno_parent(node, newnode, parent) |
| 215 newnode.expr = self.visit(node.expr, newnode) |
| 216 self.asscontext = assc |
| 217 self._delayed_assattr.append(newnode) |
| 218 return newnode |
| 219 |
| 220 def visit_assert(self, node, parent): |
| 221 """visit a Assert node by returning a fresh instance of it""" |
| 222 newnode = new.Assert() |
| 223 _lineno_parent(node, newnode, parent) |
| 224 newnode.test = self.visit(node.test, newnode) |
| 225 if node.msg is not None: |
| 226 newnode.fail = self.visit(node.msg, newnode) |
| 227 return newnode |
| 228 |
| 229 def visit_assign(self, node, parent): |
| 230 """visit a Assign node by returning a fresh instance of it""" |
| 231 newnode = new.Assign() |
| 232 _lineno_parent(node, newnode, parent) |
| 233 self.asscontext = "Ass" |
| 234 newnode.targets = [self.visit(child, newnode) for child in node.targets] |
| 235 self.asscontext = None |
| 236 newnode.value = self.visit(node.value, newnode) |
| 237 # set some function or metaclass infos XXX explain ? |
| 238 klass = newnode.parent.frame() |
| 239 if (isinstance(klass, new.Class) |
| 240 and isinstance(newnode.value, new.CallFunc) |
| 241 and isinstance(newnode.value.func, new.Name)): |
| 242 func_name = newnode.value.func.name |
| 243 for ass_node in newnode.targets: |
| 244 try: |
| 245 meth = klass[ass_node.name] |
| 246 if isinstance(meth, new.Function): |
| 247 if func_name in ('classmethod', 'staticmethod'): |
| 248 meth.type = func_name |
| 249 elif func_name == 'classproperty': # see lgc.decorators |
| 250 meth.type = 'classmethod' |
| 251 meth.extra_decorators.append(newnode.value) |
| 252 except (AttributeError, KeyError): |
| 253 continue |
| 254 return newnode |
| 255 |
| 256 def visit_assname(self, node, parent, node_name=None): |
| 257 '''visit a node and return a AssName node''' |
| 258 newnode = new.AssName() |
| 259 _set_infos(node, newnode, parent) |
| 260 newnode.name = node_name |
| 261 self._save_assignment(newnode) |
| 262 return newnode |
| 263 |
| 264 def visit_augassign(self, node, parent): |
| 265 """visit a AugAssign node by returning a fresh instance of it""" |
| 266 newnode = new.AugAssign() |
| 267 _lineno_parent(node, newnode, parent) |
| 268 newnode.op = _BIN_OP_CLASSES[node.op.__class__] + "=" |
| 269 self.asscontext = "Ass" |
| 270 newnode.target = self.visit(node.target, newnode) |
| 271 self.asscontext = None |
| 272 newnode.value = self.visit(node.value, newnode) |
| 273 return newnode |
| 274 |
| 275 def visit_backquote(self, node, parent): |
| 276 """visit a Backquote node by returning a fresh instance of it""" |
| 277 newnode = new.Backquote() |
| 278 _lineno_parent(node, newnode, parent) |
| 279 newnode.value = self.visit(node.value, newnode) |
| 280 return newnode |
| 281 |
| 282 def visit_binop(self, node, parent): |
| 283 """visit a BinOp node by returning a fresh instance of it""" |
| 284 newnode = new.BinOp() |
| 285 _lineno_parent(node, newnode, parent) |
| 286 newnode.left = self.visit(node.left, newnode) |
| 287 newnode.right = self.visit(node.right, newnode) |
| 288 newnode.op = _BIN_OP_CLASSES[node.op.__class__] |
| 289 return newnode |
| 290 |
| 291 def visit_boolop(self, node, parent): |
| 292 """visit a BoolOp node by returning a fresh instance of it""" |
| 293 newnode = new.BoolOp() |
| 294 _lineno_parent(node, newnode, parent) |
| 295 newnode.values = [self.visit(child, newnode) for child in node.values] |
| 296 newnode.op = _BOOL_OP_CLASSES[node.op.__class__] |
| 297 return newnode |
| 298 |
| 299 def visit_break(self, node, parent): |
| 300 """visit a Break node by returning a fresh instance of it""" |
| 301 newnode = new.Break() |
| 302 _set_infos(node, newnode, parent) |
| 303 return newnode |
| 304 |
| 305 def visit_callfunc(self, node, parent): |
| 306 """visit a CallFunc node by returning a fresh instance of it""" |
| 307 newnode = new.CallFunc() |
| 308 _lineno_parent(node, newnode, parent) |
| 309 newnode.func = self.visit(node.func, newnode) |
| 310 newnode.args = [self.visit(child, newnode) for child in node.args] |
| 311 if node.starargs is not None: |
| 312 newnode.starargs = self.visit(node.starargs, newnode) |
| 313 if node.kwargs is not None: |
| 314 newnode.kwargs = self.visit(node.kwargs, newnode) |
| 315 for child in node.keywords: |
| 316 newnode.args.append(self.visit(child, newnode)) |
| 317 return newnode |
| 318 |
| 319 def visit_class(self, node, parent): |
| 320 """visit a Class node to become astroid""" |
| 321 newnode = new.Class(node.name, None) |
| 322 _lineno_parent(node, newnode, parent) |
| 323 _init_set_doc(node, newnode) |
| 324 newnode.bases = [self.visit(child, newnode) for child in node.bases] |
| 325 newnode.body = [self.visit(child, newnode) for child in node.body] |
| 326 if 'decorator_list' in node._fields and node.decorator_list:# py >= 2.6 |
| 327 newnode.decorators = self.visit_decorators(node, newnode) |
| 328 newnode.parent.frame().set_local(newnode.name, newnode) |
| 329 return newnode |
| 330 |
| 331 def visit_const(self, node, parent): |
| 332 """visit a Const node by returning a fresh instance of it""" |
| 333 newnode = new.Const(node.value) |
| 334 _set_infos(node, newnode, parent) |
| 335 return newnode |
| 336 |
| 337 def visit_continue(self, node, parent): |
| 338 """visit a Continue node by returning a fresh instance of it""" |
| 339 newnode = new.Continue() |
| 340 _set_infos(node, newnode, parent) |
| 341 return newnode |
| 342 |
| 343 def visit_compare(self, node, parent): |
| 344 """visit a Compare node by returning a fresh instance of it""" |
| 345 newnode = new.Compare() |
| 346 _lineno_parent(node, newnode, parent) |
| 347 newnode.left = self.visit(node.left, newnode) |
| 348 newnode.ops = [(_CMP_OP_CLASSES[op.__class__], self.visit(expr, newnode)
) |
| 349 for (op, expr) in zip(node.ops, node.comparators)] |
| 350 return newnode |
| 351 |
| 352 def visit_comprehension(self, node, parent): |
| 353 """visit a Comprehension node by returning a fresh instance of it""" |
| 354 newnode = new.Comprehension() |
| 355 newnode.parent = parent |
| 356 self.asscontext = "Ass" |
| 357 newnode.target = self.visit(node.target, newnode) |
| 358 self.asscontext = None |
| 359 newnode.iter = self.visit(node.iter, newnode) |
| 360 newnode.ifs = [self.visit(child, newnode) for child in node.ifs] |
| 361 return newnode |
| 362 |
| 363 def visit_decorators(self, node, parent): |
| 364 """visit a Decorators node by returning a fresh instance of it""" |
| 365 # /!\ node is actually a _ast.Function node while |
| 366 # parent is a astroid.nodes.Function node |
| 367 newnode = new.Decorators() |
| 368 _lineno_parent(node, newnode, parent) |
| 369 if 'decorators' in node._fields: # py < 2.6, i.e. 2.5 |
| 370 decorators = node.decorators |
| 371 else: |
| 372 decorators = node.decorator_list |
| 373 newnode.nodes = [self.visit(child, newnode) for child in decorators] |
| 374 return newnode |
| 375 |
| 376 def visit_delete(self, node, parent): |
| 377 """visit a Delete node by returning a fresh instance of it""" |
| 378 newnode = new.Delete() |
| 379 _lineno_parent(node, newnode, parent) |
| 380 self.asscontext = "Del" |
| 381 newnode.targets = [self.visit(child, newnode) for child in node.targets] |
| 382 self.asscontext = None |
| 383 return newnode |
| 384 |
| 385 def visit_dict(self, node, parent): |
| 386 """visit a Dict node by returning a fresh instance of it""" |
| 387 newnode = new.Dict() |
| 388 _lineno_parent(node, newnode, parent) |
| 389 newnode.items = [(self.visit(key, newnode), self.visit(value, newnode)) |
| 390 for key, value in zip(node.keys, node.values)] |
| 391 return newnode |
| 392 |
| 393 def visit_dictcomp(self, node, parent): |
| 394 """visit a DictComp node by returning a fresh instance of it""" |
| 395 newnode = new.DictComp() |
| 396 _lineno_parent(node, newnode, parent) |
| 397 newnode.key = self.visit(node.key, newnode) |
| 398 newnode.value = self.visit(node.value, newnode) |
| 399 newnode.generators = [self.visit(child, newnode) |
| 400 for child in node.generators] |
| 401 return newnode |
| 402 |
| 403 def visit_discard(self, node, parent): |
| 404 """visit a Discard node by returning a fresh instance of it""" |
| 405 newnode = new.Discard() |
| 406 _lineno_parent(node, newnode, parent) |
| 407 newnode.value = self.visit(node.value, newnode) |
| 408 return newnode |
| 409 |
| 410 def visit_ellipsis(self, node, parent): |
| 411 """visit an Ellipsis node by returning a fresh instance of it""" |
| 412 newnode = new.Ellipsis() |
| 413 _set_infos(node, newnode, parent) |
| 414 return newnode |
| 415 |
| 416 def visit_emptynode(self, node, parent): |
| 417 """visit an EmptyNode node by returning a fresh instance of it""" |
| 418 newnode = new.EmptyNode() |
| 419 _set_infos(node, newnode, parent) |
| 420 return newnode |
| 421 |
| 422 def visit_excepthandler(self, node, parent): |
| 423 """visit an ExceptHandler node by returning a fresh instance of it""" |
| 424 newnode = new.ExceptHandler() |
| 425 _lineno_parent(node, newnode, parent) |
| 426 if node.type is not None: |
| 427 newnode.type = self.visit(node.type, newnode) |
| 428 if node.name is not None: |
| 429 # /!\ node.name can be a tuple |
| 430 self.asscontext = "Ass" |
| 431 newnode.name = self.visit(node.name, newnode) |
| 432 self.asscontext = None |
| 433 newnode.body = [self.visit(child, newnode) for child in node.body] |
| 434 return newnode |
| 435 |
| 436 def visit_exec(self, node, parent): |
| 437 """visit an Exec node by returning a fresh instance of it""" |
| 438 newnode = new.Exec() |
| 439 _lineno_parent(node, newnode, parent) |
| 440 newnode.expr = self.visit(node.body, newnode) |
| 441 if node.globals is not None: |
| 442 newnode.globals = self.visit(node.globals, newnode) |
| 443 if node.locals is not None: |
| 444 newnode.locals = self.visit(node.locals, newnode) |
| 445 return newnode |
| 446 |
| 447 def visit_extslice(self, node, parent): |
| 448 """visit an ExtSlice node by returning a fresh instance of it""" |
| 449 newnode = new.ExtSlice() |
| 450 newnode.parent = parent |
| 451 newnode.dims = [self.visit(dim, newnode) for dim in node.dims] |
| 452 return newnode |
| 453 |
| 454 def visit_for(self, node, parent): |
| 455 """visit a For node by returning a fresh instance of it""" |
| 456 newnode = new.For() |
| 457 _lineno_parent(node, newnode, parent) |
| 458 self.asscontext = "Ass" |
| 459 newnode.target = self.visit(node.target, newnode) |
| 460 self.asscontext = None |
| 461 newnode.iter = self.visit(node.iter, newnode) |
| 462 newnode.body = [self.visit(child, newnode) for child in node.body] |
| 463 newnode.orelse = [self.visit(child, newnode) for child in node.orelse] |
| 464 return newnode |
| 465 |
| 466 def visit_from(self, node, parent): |
| 467 """visit a From node by returning a fresh instance of it""" |
| 468 names = [(alias.name, alias.asname) for alias in node.names] |
| 469 newnode = new.From(node.module or '', names, node.level or None) |
| 470 _set_infos(node, newnode, parent) |
| 471 # store From names to add them to locals after building |
| 472 self._from_nodes.append(newnode) |
| 473 return newnode |
| 474 |
| 475 def visit_function(self, node, parent): |
| 476 """visit an Function node to become astroid""" |
| 477 self._global_names.append({}) |
| 478 newnode = new.Function(node.name, None) |
| 479 _lineno_parent(node, newnode, parent) |
| 480 _init_set_doc(node, newnode) |
| 481 newnode.args = self.visit(node.args, newnode) |
| 482 newnode.body = [self.visit(child, newnode) for child in node.body] |
| 483 if 'decorators' in node._fields: # py < 2.6 |
| 484 attr = 'decorators' |
| 485 else: |
| 486 attr = 'decorator_list' |
| 487 decorators = getattr(node, attr) |
| 488 if decorators: |
| 489 newnode.decorators = self.visit_decorators(node, newnode) |
| 490 if PY3K and node.returns: |
| 491 newnode.returns = self.visit(node.returns, newnode) |
| 492 self._global_names.pop() |
| 493 frame = newnode.parent.frame() |
| 494 if isinstance(frame, new.Class): |
| 495 if newnode.name == '__new__': |
| 496 newnode._type = 'classmethod' |
| 497 else: |
| 498 newnode._type = 'method' |
| 499 if newnode.decorators is not None: |
| 500 for decorator_expr in newnode.decorators.nodes: |
| 501 if isinstance(decorator_expr, new.Name): |
| 502 if decorator_expr.name in ('classmethod', 'staticmethod'): |
| 503 newnode._type = decorator_expr.name |
| 504 elif decorator_expr.name == 'classproperty': |
| 505 newnode._type = 'classmethod' |
| 506 frame.set_local(newnode.name, newnode) |
| 507 return newnode |
| 508 |
| 509 def visit_genexpr(self, node, parent): |
| 510 """visit a GenExpr node by returning a fresh instance of it""" |
| 511 newnode = new.GenExpr() |
| 512 _lineno_parent(node, newnode, parent) |
| 513 newnode.elt = self.visit(node.elt, newnode) |
| 514 newnode.generators = [self.visit(child, newnode) for child in node.gener
ators] |
| 515 return newnode |
| 516 |
| 517 def visit_getattr(self, node, parent): |
| 518 """visit a Getattr node by returning a fresh instance of it""" |
| 519 if self.asscontext == "Del": |
| 520 # FIXME : maybe we should reintroduce and visit_delattr ? |
| 521 # for instance, deactivating asscontext |
| 522 newnode = new.DelAttr() |
| 523 elif self.asscontext == "Ass": |
| 524 # FIXME : maybe we should call visit_assattr ? |
| 525 newnode = new.AssAttr() |
| 526 self._delayed_assattr.append(newnode) |
| 527 else: |
| 528 newnode = new.Getattr() |
| 529 _lineno_parent(node, newnode, parent) |
| 530 asscontext, self.asscontext = self.asscontext, None |
| 531 newnode.expr = self.visit(node.value, newnode) |
| 532 self.asscontext = asscontext |
| 533 newnode.attrname = node.attr |
| 534 return newnode |
| 535 |
| 536 def visit_global(self, node, parent): |
| 537 """visit an Global node to become astroid""" |
| 538 newnode = new.Global(node.names) |
| 539 _set_infos(node, newnode, parent) |
| 540 if self._global_names: # global at the module level, no effect |
| 541 for name in node.names: |
| 542 self._global_names[-1].setdefault(name, []).append(newnode) |
| 543 return newnode |
| 544 |
| 545 def visit_if(self, node, parent): |
| 546 """visit a If node by returning a fresh instance of it""" |
| 547 newnode = new.If() |
| 548 _lineno_parent(node, newnode, parent) |
| 549 newnode.test = self.visit(node.test, newnode) |
| 550 newnode.body = [self.visit(child, newnode) for child in node.body] |
| 551 newnode.orelse = [self.visit(child, newnode) for child in node.orelse] |
| 552 return newnode |
| 553 |
| 554 def visit_ifexp(self, node, parent): |
| 555 """visit a IfExp node by returning a fresh instance of it""" |
| 556 newnode = new.IfExp() |
| 557 _lineno_parent(node, newnode, parent) |
| 558 newnode.test = self.visit(node.test, newnode) |
| 559 newnode.body = self.visit(node.body, newnode) |
| 560 newnode.orelse = self.visit(node.orelse, newnode) |
| 561 return newnode |
| 562 |
| 563 def visit_import(self, node, parent): |
| 564 """visit a Import node by returning a fresh instance of it""" |
| 565 newnode = new.Import() |
| 566 _set_infos(node, newnode, parent) |
| 567 newnode.names = [(alias.name, alias.asname) for alias in node.names] |
| 568 # save import names in parent's locals: |
| 569 for (name, asname) in newnode.names: |
| 570 name = asname or name |
| 571 newnode.parent.set_local(name.split('.')[0], newnode) |
| 572 return newnode |
| 573 |
| 574 def visit_index(self, node, parent): |
| 575 """visit a Index node by returning a fresh instance of it""" |
| 576 newnode = new.Index() |
| 577 newnode.parent = parent |
| 578 newnode.value = self.visit(node.value, newnode) |
| 579 return newnode |
| 580 |
| 581 def visit_keyword(self, node, parent): |
| 582 """visit a Keyword node by returning a fresh instance of it""" |
| 583 newnode = new.Keyword() |
| 584 newnode.parent = parent |
| 585 newnode.arg = node.arg |
| 586 newnode.value = self.visit(node.value, newnode) |
| 587 return newnode |
| 588 |
| 589 def visit_lambda(self, node, parent): |
| 590 """visit a Lambda node by returning a fresh instance of it""" |
| 591 newnode = new.Lambda() |
| 592 _lineno_parent(node, newnode, parent) |
| 593 newnode.args = self.visit(node.args, newnode) |
| 594 newnode.body = self.visit(node.body, newnode) |
| 595 return newnode |
| 596 |
| 597 def visit_list(self, node, parent): |
| 598 """visit a List node by returning a fresh instance of it""" |
| 599 newnode = new.List() |
| 600 _lineno_parent(node, newnode, parent) |
| 601 newnode.elts = [self.visit(child, newnode) for child in node.elts] |
| 602 return newnode |
| 603 |
| 604 def visit_listcomp(self, node, parent): |
| 605 """visit a ListComp node by returning a fresh instance of it""" |
| 606 newnode = new.ListComp() |
| 607 _lineno_parent(node, newnode, parent) |
| 608 newnode.elt = self.visit(node.elt, newnode) |
| 609 newnode.generators = [self.visit(child, newnode) |
| 610 for child in node.generators] |
| 611 return newnode |
| 612 |
| 613 def visit_name(self, node, parent): |
| 614 """visit a Name node by returning a fresh instance of it""" |
| 615 # True and False can be assigned to something in py2x, so we have to |
| 616 # check first the asscontext |
| 617 if self.asscontext == "Del": |
| 618 newnode = new.DelName() |
| 619 elif self.asscontext is not None: # Ass |
| 620 assert self.asscontext == "Ass" |
| 621 newnode = new.AssName() |
| 622 elif node.id in CONST_NAME_TRANSFORMS: |
| 623 newnode = new.Const(CONST_NAME_TRANSFORMS[node.id]) |
| 624 _set_infos(node, newnode, parent) |
| 625 return newnode |
| 626 else: |
| 627 newnode = new.Name() |
| 628 _lineno_parent(node, newnode, parent) |
| 629 newnode.name = node.id |
| 630 # XXX REMOVE me : |
| 631 if self.asscontext in ('Del', 'Ass'): # 'Aug' ?? |
| 632 self._save_assignment(newnode) |
| 633 return newnode |
| 634 |
| 635 def visit_bytes(self, node, parent): |
| 636 """visit a Bytes node by returning a fresh instance of Const""" |
| 637 newnode = new.Const(node.s) |
| 638 _set_infos(node, newnode, parent) |
| 639 return newnode |
| 640 |
| 641 def visit_num(self, node, parent): |
| 642 """visit a Num node by returning a fresh instance of Const""" |
| 643 newnode = new.Const(node.n) |
| 644 _set_infos(node, newnode, parent) |
| 645 return newnode |
| 646 |
| 647 def visit_pass(self, node, parent): |
| 648 """visit a Pass node by returning a fresh instance of it""" |
| 649 newnode = new.Pass() |
| 650 _set_infos(node, newnode, parent) |
| 651 return newnode |
| 652 |
| 653 def visit_str(self, node, parent): |
| 654 """visit a Str node by returning a fresh instance of Const""" |
| 655 newnode = new.Const(node.s) |
| 656 _set_infos(node, newnode, parent) |
| 657 return newnode |
| 658 |
| 659 def visit_print(self, node, parent): |
| 660 """visit a Print node by returning a fresh instance of it""" |
| 661 newnode = new.Print() |
| 662 _lineno_parent(node, newnode, parent) |
| 663 newnode.nl = node.nl |
| 664 if node.dest is not None: |
| 665 newnode.dest = self.visit(node.dest, newnode) |
| 666 newnode.values = [self.visit(child, newnode) for child in node.values] |
| 667 return newnode |
| 668 |
| 669 def visit_raise(self, node, parent): |
| 670 """visit a Raise node by returning a fresh instance of it""" |
| 671 newnode = new.Raise() |
| 672 _lineno_parent(node, newnode, parent) |
| 673 if node.type is not None: |
| 674 newnode.exc = self.visit(node.type, newnode) |
| 675 if node.inst is not None: |
| 676 newnode.inst = self.visit(node.inst, newnode) |
| 677 if node.tback is not None: |
| 678 newnode.tback = self.visit(node.tback, newnode) |
| 679 return newnode |
| 680 |
| 681 def visit_return(self, node, parent): |
| 682 """visit a Return node by returning a fresh instance of it""" |
| 683 newnode = new.Return() |
| 684 _lineno_parent(node, newnode, parent) |
| 685 if node.value is not None: |
| 686 newnode.value = self.visit(node.value, newnode) |
| 687 return newnode |
| 688 |
| 689 def visit_set(self, node, parent): |
| 690 """visit a Set node by returning a fresh instance of it""" |
| 691 newnode = new.Set() |
| 692 _lineno_parent(node, newnode, parent) |
| 693 newnode.elts = [self.visit(child, newnode) for child in node.elts] |
| 694 return newnode |
| 695 |
| 696 def visit_setcomp(self, node, parent): |
| 697 """visit a SetComp node by returning a fresh instance of it""" |
| 698 newnode = new.SetComp() |
| 699 _lineno_parent(node, newnode, parent) |
| 700 newnode.elt = self.visit(node.elt, newnode) |
| 701 newnode.generators = [self.visit(child, newnode) |
| 702 for child in node.generators] |
| 703 return newnode |
| 704 |
| 705 def visit_slice(self, node, parent): |
| 706 """visit a Slice node by returning a fresh instance of it""" |
| 707 newnode = new.Slice() |
| 708 newnode.parent = parent |
| 709 if node.lower is not None: |
| 710 newnode.lower = self.visit(node.lower, newnode) |
| 711 if node.upper is not None: |
| 712 newnode.upper = self.visit(node.upper, newnode) |
| 713 if node.step is not None: |
| 714 newnode.step = self.visit(node.step, newnode) |
| 715 return newnode |
| 716 |
| 717 def visit_subscript(self, node, parent): |
| 718 """visit a Subscript node by returning a fresh instance of it""" |
| 719 newnode = new.Subscript() |
| 720 _lineno_parent(node, newnode, parent) |
| 721 subcontext, self.asscontext = self.asscontext, None |
| 722 newnode.value = self.visit(node.value, newnode) |
| 723 newnode.slice = self.visit(node.slice, newnode) |
| 724 self.asscontext = subcontext |
| 725 return newnode |
| 726 |
| 727 def visit_tryexcept(self, node, parent): |
| 728 """visit a TryExcept node by returning a fresh instance of it""" |
| 729 newnode = new.TryExcept() |
| 730 _lineno_parent(node, newnode, parent) |
| 731 newnode.body = [self.visit(child, newnode) for child in node.body] |
| 732 newnode.handlers = [self.visit(child, newnode) for child in node.handler
s] |
| 733 newnode.orelse = [self.visit(child, newnode) for child in node.orelse] |
| 734 return newnode |
| 735 |
| 736 def visit_tryfinally(self, node, parent): |
| 737 """visit a TryFinally node by returning a fresh instance of it""" |
| 738 newnode = new.TryFinally() |
| 739 _lineno_parent(node, newnode, parent) |
| 740 newnode.body = [self.visit(child, newnode) for child in node.body] |
| 741 newnode.finalbody = [self.visit(n, newnode) for n in node.finalbody] |
| 742 return newnode |
| 743 |
| 744 def visit_tuple(self, node, parent): |
| 745 """visit a Tuple node by returning a fresh instance of it""" |
| 746 newnode = new.Tuple() |
| 747 _lineno_parent(node, newnode, parent) |
| 748 newnode.elts = [self.visit(child, newnode) for child in node.elts] |
| 749 return newnode |
| 750 |
| 751 def visit_unaryop(self, node, parent): |
| 752 """visit a UnaryOp node by returning a fresh instance of it""" |
| 753 newnode = new.UnaryOp() |
| 754 _lineno_parent(node, newnode, parent) |
| 755 newnode.operand = self.visit(node.operand, newnode) |
| 756 newnode.op = _UNARY_OP_CLASSES[node.op.__class__] |
| 757 return newnode |
| 758 |
| 759 def visit_while(self, node, parent): |
| 760 """visit a While node by returning a fresh instance of it""" |
| 761 newnode = new.While() |
| 762 _lineno_parent(node, newnode, parent) |
| 763 newnode.test = self.visit(node.test, newnode) |
| 764 newnode.body = [self.visit(child, newnode) for child in node.body] |
| 765 newnode.orelse = [self.visit(child, newnode) for child in node.orelse] |
| 766 return newnode |
| 767 |
| 768 def visit_with(self, node, parent): |
| 769 newnode = new.With() |
| 770 _lineno_parent(node, newnode, parent) |
| 771 expr = self.visit(node.context_expr, newnode) |
| 772 self.asscontext = "Ass" |
| 773 if node.optional_vars is not None: |
| 774 vars = self.visit(node.optional_vars, newnode) |
| 775 else: |
| 776 vars = None |
| 777 self.asscontext = None |
| 778 newnode.items = [(expr, vars)] |
| 779 newnode.body = [self.visit(child, newnode) for child in node.body] |
| 780 return newnode |
| 781 |
| 782 def visit_yield(self, node, parent): |
| 783 """visit a Yield node by returning a fresh instance of it""" |
| 784 return _create_yield_node(node, parent, self, new.Yield) |
| 785 |
| 786 class TreeRebuilder3k(TreeRebuilder): |
| 787 """extend and overwrite TreeRebuilder for python3k""" |
| 788 |
| 789 def visit_arg(self, node, parent): |
| 790 """visit a arg node by returning a fresh AssName instance""" |
| 791 # the <arg> node is coming from py>=3.0, but we use AssName in py2.x |
| 792 # XXX or we should instead introduce a Arg node in astroid ? |
| 793 return self.visit_assname(node, parent, node.arg) |
| 794 |
| 795 def visit_nameconstant(self, node, parent): |
| 796 # in Python 3.4 we have NameConstant for True / False / None |
| 797 newnode = new.Const(node.value) |
| 798 _set_infos(node, newnode, parent) |
| 799 return newnode |
| 800 |
| 801 def visit_arguments(self, node, parent): |
| 802 newnode = super(TreeRebuilder3k, self).visit_arguments(node, parent) |
| 803 self.asscontext = "Ass" |
| 804 newnode.kwonlyargs = [self.visit(child, newnode) for child in node.kwonl
yargs] |
| 805 self.asscontext = None |
| 806 newnode.kw_defaults = [self.visit(child, newnode) if child else None for
child in node.kw_defaults] |
| 807 newnode.annotations = [ |
| 808 self.visit(arg.annotation, newnode) if arg.annotation else None |
| 809 for arg in node.args] |
| 810 return newnode |
| 811 |
| 812 def visit_excepthandler(self, node, parent): |
| 813 """visit an ExceptHandler node by returning a fresh instance of it""" |
| 814 newnode = new.ExceptHandler() |
| 815 _lineno_parent(node, newnode, parent) |
| 816 if node.type is not None: |
| 817 newnode.type = self.visit(node.type, newnode) |
| 818 if node.name is not None: |
| 819 newnode.name = self.visit_assname(node, newnode, node.name) |
| 820 newnode.body = [self.visit(child, newnode) for child in node.body] |
| 821 return newnode |
| 822 |
| 823 def visit_nonlocal(self, node, parent): |
| 824 """visit a Nonlocal node and return a new instance of it""" |
| 825 newnode = new.Nonlocal(node.names) |
| 826 _set_infos(node, newnode, parent) |
| 827 return newnode |
| 828 |
| 829 def visit_raise(self, node, parent): |
| 830 """visit a Raise node by returning a fresh instance of it""" |
| 831 newnode = new.Raise() |
| 832 _lineno_parent(node, newnode, parent) |
| 833 # no traceback; anyway it is not used in Pylint |
| 834 if node.exc is not None: |
| 835 newnode.exc = self.visit(node.exc, newnode) |
| 836 if node.cause is not None: |
| 837 newnode.cause = self.visit(node.cause, newnode) |
| 838 return newnode |
| 839 |
| 840 def visit_starred(self, node, parent): |
| 841 """visit a Starred node and return a new instance of it""" |
| 842 newnode = new.Starred() |
| 843 _lineno_parent(node, newnode, parent) |
| 844 newnode.value = self.visit(node.value, newnode) |
| 845 return newnode |
| 846 |
| 847 def visit_try(self, node, parent): |
| 848 # python 3.3 introduce a new Try node replacing TryFinally/TryExcept nod
es |
| 849 if node.finalbody: |
| 850 newnode = new.TryFinally() |
| 851 _lineno_parent(node, newnode, parent) |
| 852 newnode.finalbody = [self.visit(n, newnode) for n in node.finalbody] |
| 853 if node.handlers: |
| 854 excnode = new.TryExcept() |
| 855 _lineno_parent(node, excnode, newnode) |
| 856 excnode.body = [self.visit(child, excnode) for child in node.bod
y] |
| 857 excnode.handlers = [self.visit(child, excnode) for child in node
.handlers] |
| 858 excnode.orelse = [self.visit(child, excnode) for child in node.o
relse] |
| 859 newnode.body = [excnode] |
| 860 else: |
| 861 newnode.body = [self.visit(child, newnode) for child in node.bod
y] |
| 862 elif node.handlers: |
| 863 newnode = new.TryExcept() |
| 864 _lineno_parent(node, newnode, parent) |
| 865 newnode.body = [self.visit(child, newnode) for child in node.body] |
| 866 newnode.handlers = [self.visit(child, newnode) for child in node.han
dlers] |
| 867 newnode.orelse = [self.visit(child, newnode) for child in node.orels
e] |
| 868 return newnode |
| 869 |
| 870 def visit_with(self, node, parent): |
| 871 if 'items' not in node._fields: |
| 872 # python < 3.3 |
| 873 return super(TreeRebuilder3k, self).visit_with(node, parent) |
| 874 |
| 875 newnode = new.With() |
| 876 _lineno_parent(node, newnode, parent) |
| 877 def visit_child(child): |
| 878 expr = self.visit(child.context_expr, newnode) |
| 879 self.asscontext = 'Ass' |
| 880 if child.optional_vars: |
| 881 var = self.visit(child.optional_vars, newnode) |
| 882 else: |
| 883 var = None |
| 884 self.asscontext = None |
| 885 return expr, var |
| 886 newnode.items = [visit_child(child) |
| 887 for child in node.items] |
| 888 newnode.body = [self.visit(child, newnode) for child in node.body] |
| 889 return newnode |
| 890 |
| 891 def visit_yieldfrom(self, node, parent): |
| 892 return _create_yield_node(node, parent, self, new.YieldFrom) |
| 893 |
| 894 def visit_class(self, node, parent): |
| 895 newnode = super(TreeRebuilder3k, self).visit_class(node, parent) |
| 896 newnode._newstyle = True |
| 897 for keyword in node.keywords: |
| 898 if keyword.arg == 'metaclass': |
| 899 newnode._metaclass = self.visit(keyword, newnode).value |
| 900 break |
| 901 return newnode |
| 902 |
| 903 if sys.version_info >= (3, 0): |
| 904 TreeRebuilder = TreeRebuilder3k |
| 905 |
| 906 |
OLD | NEW |