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