1 """Python abstract syntax node definitions 2 3 This file was originally generated by Tools/compiler/astgen.py 4 """ 5 from compiler.consts import CO_VARARGS, CO_VARKEYWORDS 6 7 def flatten(seq): 8 l = [] 9 for elt in seq: 10 if isinstance(elt, (tuple, list)): 11 for elt2 in flatten(elt): 12 l.append(elt2) 13 else: 14 l.append(elt) 15 return l 16 17 def flatten_nodes(seq): 18 return [n for n in flatten(seq) if isinstance(n, Node)] 19 20 def flatten_statement(seq): 21 l = [] 22 for elt in seq: 23 if isinstance(elt, Stmt): 24 l += flatten_statement(elt) 25 else: 26 l.append(elt) 27 return l 28 29 def flatten_assignment(node): 30 l = [] 31 if isinstance(node, (AssList, AssTuple)): 32 for n in node.nodes: 33 l += flatten_assignment(n) 34 else: 35 l.append(node) 36 return l 37 38 def is_deletion(node): 39 return isinstance(node, (AssAttr, AssName)) and node.flags == "OP_DELETE" 40 41 def docstring(s): 42 if s.find("\n") != -1: 43 if s.find("'''") != -1: 44 return '"""%s"""' % s.replace('"""', '\\"\\"\\"') 45 else: 46 return "'''%s'''" % s.replace("'''", "\\'\\'\\'") 47 else: 48 return repr(s) 49 50 def indent(s): 51 return s.replace("\n", "\n\t") 52 53 def decode_function(node): 54 star = (node.flags & 4 != 0) and 1 or 0 55 dstar = (node.flags & 8 != 0) and 1 or 0 56 argnames = node.argnames[:] 57 58 # Add stars to star and dstar parameters. 59 60 if star: 61 argnames[-dstar-star] = "*%s" % argnames[-dstar-star] 62 if dstar: 63 argnames[-dstar] = "**%s" % argnames[-dstar] 64 65 # Map defaults to parameters. 66 67 defaults = [None] * (len(node.argnames) - star - dstar - len(node.defaults)) + list(node.defaults) + [None] * (star + dstar) 68 return [(default and "%s=%s" % (argname, default) or argname) for (argname, default) in zip(argnames, defaults)] 69 70 nodes = {} 71 72 class AttributeUser: 73 74 "Annotation-related node." 75 76 def __init__(self): 77 self.unit = None 78 79 # Name and usage observations. 80 81 self._attrnames = None 82 self._attrcombined = None 83 self._attrmerged = None 84 85 # Related nodes. 86 87 self._attrbranches = None 88 self._attrcontributors = None 89 self._attrdefs = None 90 91 # Deductions. 92 93 self._attrtypes = None 94 self._attrspecifictypes = None 95 96 class AttributeAccessor: 97 98 "Access-related node." 99 100 def __init__(self): 101 self._attr = None 102 self._attrusers = None 103 self._username = None 104 105 # Deductions. 106 107 self._access_type = None 108 self._value_deduced = None 109 self._attr_deduced = None 110 self._set_context = None 111 112 self._attrs_deduced = None 113 self._attrs_deduced_from_usage = None 114 self._attrs_deduced_from_specific_usage = None 115 self._position_deduced = None 116 117 class OperatorUser: 118 119 "Operator-related node." 120 121 def __init__(self): 122 self._module = None 123 124 class Node(AttributeUser): 125 126 "Abstract base class for ast nodes." 127 128 def getChildren(self): 129 pass # implemented by subclasses 130 131 def __iter__(self): 132 for n in self.getChildren(): 133 yield n 134 135 def asList(self): # for backwards compatibility 136 return self.getChildren() 137 138 def getChildNodes(self): 139 pass # implemented by subclasses 140 141 def visit(self, visitor, *args): 142 return visitor.default(self, *args) 143 144 class EmptyNode(Node): 145 pass 146 147 class Expression(Node): 148 # Expression is an artificial node class to support "eval" 149 nodes["expression"] = "Expression" 150 def __init__(self, node): 151 Node.__init__(self) 152 self.node = node 153 154 def getChildren(self): 155 return self.node, 156 157 def getChildNodes(self): 158 return self.node, 159 160 def __repr__(self): 161 return "Expression(%r)" % (self.node,) 162 163 def __str__(self): 164 return str(self.node) 165 166 def visit(self, visitor, *args): 167 return visitor.visitExpression(self, *args) 168 169 class Add(Node, OperatorUser): 170 def __init__(self, leftright, lineno=None): 171 Node.__init__(self) 172 OperatorUser.__init__(self) 173 self.left = leftright[0] 174 self.right = leftright[1] 175 self.lineno = lineno 176 177 def getChildren(self): 178 return self.left, self.right 179 180 def getChildNodes(self): 181 return self.left, self.right 182 183 def __repr__(self): 184 return "Add((%r, %r))" % (self.left, self.right) 185 186 def __str__(self): 187 return "(%s + %s)" % (self.left, self.right) 188 189 def visit(self, visitor, *args): 190 return visitor.visitAdd(self, *args) 191 192 class And(Node): 193 def __init__(self, nodes, lineno=None): 194 Node.__init__(self) 195 self.nodes = nodes 196 self.lineno = lineno 197 198 def getChildren(self): 199 return tuple(flatten(self.nodes)) 200 201 def getChildNodes(self): 202 nodelist = [] 203 nodelist.extend(flatten_nodes(self.nodes)) 204 return tuple(nodelist) 205 206 def __repr__(self): 207 return "And(%r)" % (self.nodes,) 208 209 def __str__(self): 210 return "(%s)" % " and ".join(map(str, self.nodes)) 211 212 def visit(self, visitor, *args): 213 return visitor.visitAnd(self, *args) 214 215 class AssAttr(Node, AttributeAccessor): 216 def __init__(self, expr, attrname, flags, lineno=None): 217 Node.__init__(self) 218 AttributeAccessor.__init__(self) 219 self.expr = expr 220 self.attrname = attrname 221 self.flags = flags 222 self.lineno = lineno 223 224 # Additional annotations. 225 226 self._expr = None 227 228 def getChildren(self): 229 return self.expr, self.attrname, self.flags 230 231 def getChildNodes(self): 232 return self.expr, 233 234 def __repr__(self): 235 return "AssAttr(%r, %r, %r)" % (self.expr, self.attrname, self.flags) 236 237 def __str__(self): 238 if self.flags == "OP_DELETE": 239 return "del %s.%s" % (self.expr, self.attrname) 240 else: 241 return "%s.%s" % (self.expr, self.attrname) 242 243 def visit(self, visitor, *args): 244 return visitor.visitAssAttr(self, *args) 245 246 class AssList(Node): 247 def __init__(self, nodes, lineno=None): 248 Node.__init__(self) 249 self.nodes = nodes 250 self.lineno = lineno 251 252 def getChildren(self): 253 return tuple(flatten(self.nodes)) 254 255 def getChildNodes(self): 256 nodelist = [] 257 nodelist.extend(flatten_nodes(self.nodes)) 258 return tuple(nodelist) 259 260 def __repr__(self): 261 return "AssList(%r)" % (self.nodes,) 262 263 def __str__(self): 264 nodes = flatten_assignment(self) 265 if nodes and is_deletion(nodes[0]): 266 return "; ".join(map(str, self.nodes)) 267 else: 268 return "[%s]" % ", ".join(map(str, self.nodes)) 269 270 def visit(self, visitor, *args): 271 return visitor.visitAssList(self, *args) 272 273 class AssName(Node): 274 def __init__(self, name, flags, lineno=None): 275 Node.__init__(self) 276 self.name = name 277 self.flags = flags 278 self.lineno = lineno 279 280 def getChildren(self): 281 return self.name, self.flags 282 283 def getChildNodes(self): 284 return () 285 286 def __repr__(self): 287 return "AssName(%r, %r)" % (self.name, self.flags) 288 289 def __str__(self): 290 if self.flags == "OP_DELETE": 291 return "del %s" % self.name 292 else: 293 return str(self.name) 294 295 def visit(self, visitor, *args): 296 return visitor.visitAssName(self, *args) 297 298 class AssTuple(Node): 299 def __init__(self, nodes, lineno=None): 300 Node.__init__(self) 301 self.nodes = nodes 302 self.lineno = lineno 303 304 def getChildren(self): 305 return tuple(flatten(self.nodes)) 306 307 def getChildNodes(self): 308 nodelist = [] 309 nodelist.extend(flatten_nodes(self.nodes)) 310 return tuple(nodelist) 311 312 def __repr__(self): 313 return "AssTuple(%r)" % (self.nodes,) 314 315 def __str__(self): 316 nodes = flatten_assignment(self) 317 if nodes and is_deletion(nodes[0]): 318 return "; ".join(map(str, self.nodes)) 319 else: 320 return "(%s)" % ", ".join(map(str, self.nodes)) 321 322 def visit(self, visitor, *args): 323 return visitor.visitAssTuple(self, *args) 324 325 class Assert(Node): 326 def __init__(self, test, fail, lineno=None): 327 Node.__init__(self) 328 self.test = test 329 self.fail = fail 330 self.lineno = lineno 331 332 def getChildren(self): 333 children = [] 334 children.append(self.test) 335 children.append(self.fail) 336 return tuple(children) 337 338 def getChildNodes(self): 339 nodelist = [] 340 nodelist.append(self.test) 341 if self.fail is not None: 342 nodelist.append(self.fail) 343 return tuple(nodelist) 344 345 def __repr__(self): 346 return "Assert(%r, %r)" % (self.test, self.fail) 347 348 def __str__(self): 349 return "assert %s%s" % (self.test, self.fail and ", %s" % self.fail or "") 350 351 def visit(self, visitor, *args): 352 return visitor.visitAssert(self, *args) 353 354 class Assign(Node): 355 def __init__(self, nodes, expr, lineno=None): 356 Node.__init__(self) 357 self.nodes = nodes 358 self.expr = expr 359 self.lineno = lineno 360 361 def getChildren(self): 362 children = [] 363 children.extend(flatten(self.nodes)) 364 children.append(self.expr) 365 return tuple(children) 366 367 def getChildNodes(self): 368 nodelist = [] 369 nodelist.extend(flatten_nodes(self.nodes)) 370 nodelist.append(self.expr) 371 return tuple(nodelist) 372 373 def __repr__(self): 374 return "Assign(%r, %r)" % (self.nodes, self.expr) 375 376 def __str__(self): 377 return "%s = %s" % (", ".join(map(str, self.nodes)), self.expr) 378 379 def visit(self, visitor, *args): 380 return visitor.visitAssign(self, *args) 381 382 class AugAssign(Node, OperatorUser): 383 def __init__(self, node, op, expr, lineno=None): 384 Node.__init__(self) 385 OperatorUser.__init__(self) 386 self.node = node 387 self.op = op 388 self.expr = expr 389 self.lineno = lineno 390 391 def getChildren(self): 392 return self.node, self.op, self.expr 393 394 def getChildNodes(self): 395 return self.node, self.expr 396 397 def __repr__(self): 398 return "AugAssign(%r, %r, %r)" % (self.node, self.op, self.expr) 399 400 def __str__(self): 401 return "%s %s %s" % (self.node, self.op, self.expr) 402 403 def visit(self, visitor, *args): 404 return visitor.visitAugAssign(self, *args) 405 406 class Backquote(Node): 407 def __init__(self, expr, lineno=None): 408 Node.__init__(self) 409 self.expr = expr 410 self.lineno = lineno 411 412 def getChildren(self): 413 return self.expr, 414 415 def getChildNodes(self): 416 return self.expr, 417 418 def __repr__(self): 419 return "Backquote(%r)" % (self.expr,) 420 421 def __str__(self): 422 return "`%s`" % self.expr 423 424 def visit(self, visitor, *args): 425 return visitor.visitBackquote(self, *args) 426 427 class Bitand(Node, OperatorUser): 428 def __init__(self, nodes, lineno=None): 429 Node.__init__(self) 430 OperatorUser.__init__(self) 431 self.nodes = nodes 432 self.lineno = lineno 433 434 def getChildren(self): 435 return tuple(flatten(self.nodes)) 436 437 def getChildNodes(self): 438 nodelist = [] 439 nodelist.extend(flatten_nodes(self.nodes)) 440 return tuple(nodelist) 441 442 def __repr__(self): 443 return "Bitand(%r)" % (self.nodes,) 444 445 def __str__(self): 446 return "(%s)" % " & ".join(map(str, self.nodes)) 447 448 def visit(self, visitor, *args): 449 return visitor.visitBitand(self, *args) 450 451 class Bitor(Node, OperatorUser): 452 def __init__(self, nodes, lineno=None): 453 Node.__init__(self) 454 OperatorUser.__init__(self) 455 self.nodes = nodes 456 self.lineno = lineno 457 458 def getChildren(self): 459 return tuple(flatten(self.nodes)) 460 461 def getChildNodes(self): 462 nodelist = [] 463 nodelist.extend(flatten_nodes(self.nodes)) 464 return tuple(nodelist) 465 466 def __repr__(self): 467 return "Bitor(%r)" % (self.nodes,) 468 469 def __str__(self): 470 return "(%s)" % " | ".join(map(str, self.nodes)) 471 472 def visit(self, visitor, *args): 473 return visitor.visitBitor(self, *args) 474 475 class Bitxor(Node, OperatorUser): 476 def __init__(self, nodes, lineno=None): 477 Node.__init__(self) 478 OperatorUser.__init__(self) 479 self.nodes = nodes 480 self.lineno = lineno 481 482 def getChildren(self): 483 return tuple(flatten(self.nodes)) 484 485 def getChildNodes(self): 486 nodelist = [] 487 nodelist.extend(flatten_nodes(self.nodes)) 488 return tuple(nodelist) 489 490 def __repr__(self): 491 return "Bitxor(%r)" % (self.nodes,) 492 493 def __str__(self): 494 return "(%s)" % " ^ ".join(map(str, self.nodes)) 495 496 def visit(self, visitor, *args): 497 return visitor.visitBitxor(self, *args) 498 499 class Break(Node): 500 def __init__(self, lineno=None): 501 Node.__init__(self) 502 self.lineno = lineno 503 504 def getChildren(self): 505 return () 506 507 def getChildNodes(self): 508 return () 509 510 def __repr__(self): 511 return "Break()" 512 513 def __str__(self): 514 return "break" 515 516 def visit(self, visitor, *args): 517 return visitor.visitBreak(self, *args) 518 519 class CallFunc(Node): 520 def __init__(self, node, args, star_args = None, dstar_args = None, lineno=None): 521 Node.__init__(self) 522 self.node = node 523 self.args = args 524 self.star_args = star_args 525 self.dstar_args = dstar_args 526 self.lineno = lineno 527 528 def getChildren(self): 529 children = [] 530 children.append(self.node) 531 children.extend(flatten(self.args)) 532 children.append(self.star_args) 533 children.append(self.dstar_args) 534 return tuple(children) 535 536 def getChildNodes(self): 537 nodelist = [] 538 nodelist.append(self.node) 539 nodelist.extend(flatten_nodes(self.args)) 540 if self.star_args is not None: 541 nodelist.append(self.star_args) 542 if self.dstar_args is not None: 543 nodelist.append(self.dstar_args) 544 return tuple(nodelist) 545 546 def __repr__(self): 547 args = [] 548 if self.dstar_args: 549 args.insert(0, repr(self.dstar_args)) 550 if args or self.star_args: 551 args.insert(0, repr(self.star_args)) 552 return "CallFunc(%r, %r%s)" % (self.node, self.args, args and (", %s" % ", ".join(args)) or "") 553 554 def __str__(self): 555 star_args = self.star_args and ["*%s" % self.star_args] or [] 556 dstar_args = self.dstar_args and ["**%s" % self.dstar_args] or [] 557 return "%s(%s)" % (self.node, ", ".join(map(str, self.args + star_args + dstar_args))) 558 559 def visit(self, visitor, *args): 560 return visitor.visitCallFunc(self, *args) 561 562 class Class(Node): 563 def __init__(self, name, bases, doc, code, decorators = None, lineno=None): 564 Node.__init__(self) 565 self.name = name 566 self.bases = bases 567 self.doc = doc 568 self.code = code 569 self.decorators = decorators 570 self.lineno = lineno 571 572 def getChildren(self): 573 children = [] 574 children.append(self.name) 575 children.extend(flatten(self.bases)) 576 children.append(self.doc) 577 children.append(self.code) 578 children.append(self.decorators) 579 return tuple(children) 580 581 def getChildNodes(self): 582 nodelist = [] 583 nodelist.extend(flatten_nodes(self.bases)) 584 nodelist.append(self.code) 585 if self.decorators is not None: 586 nodelist.append(self.decorators) 587 return tuple(nodelist) 588 589 def __repr__(self): 590 return "Class(%r, %r, %r, %r, %r)" % (self.name, self.bases, self.doc, self.code, self.decorators) 591 592 def __str__(self): 593 return "%sclass %s%s:%s%s\n" % ( 594 self.decorators and "%s\n" % "\n".join([("@%s" % decorator) for decorator in self.decorators]) or "", 595 self.name, 596 self.bases and "(%s)" % ", ".join(map(str, self.bases)) or "", 597 self.doc and "\n\t" + docstring(self.doc) or "", 598 indent("\n%s" % self.code) 599 ) 600 601 def visit(self, visitor, *args): 602 return visitor.visitClass(self, *args) 603 604 class Compare(Node, OperatorUser): 605 def __init__(self, expr, ops, lineno=None): 606 Node.__init__(self) 607 OperatorUser.__init__(self) 608 self.expr = expr 609 self.ops = ops 610 self.lineno = lineno 611 612 def getChildren(self): 613 children = [] 614 children.append(self.expr) 615 children.extend(flatten(self.ops)) 616 return tuple(children) 617 618 def getChildNodes(self): 619 nodelist = [] 620 nodelist.append(self.expr) 621 nodelist.extend(flatten_nodes(self.ops)) 622 return tuple(nodelist) 623 624 def __repr__(self): 625 return "Compare(%r, %r)" % (self.expr, self.ops) 626 627 def __str__(self): 628 return "%s %s" % (self.expr, " ".join([("%s %s" % op) for op in self.ops])) 629 630 def visit(self, visitor, *args): 631 return visitor.visitCompare(self, *args) 632 633 class Const(Node): 634 def __init__(self, value, lineno=None): 635 Node.__init__(self) 636 self.value = value 637 self.lineno = lineno 638 639 def getChildren(self): 640 return self.value, 641 642 def getChildNodes(self): 643 return () 644 645 def __repr__(self): 646 return "Const(%r)" % (self.value,) 647 648 def __str__(self): 649 return repr(self.value) 650 651 def visit(self, visitor, *args): 652 return visitor.visitConst(self, *args) 653 654 class Continue(Node): 655 def __init__(self, lineno=None): 656 Node.__init__(self) 657 self.lineno = lineno 658 659 def getChildren(self): 660 return () 661 662 def getChildNodes(self): 663 return () 664 665 def __repr__(self): 666 return "Continue()" 667 668 def __str__(self): 669 return "continue" 670 671 def visit(self, visitor, *args): 672 return visitor.visitContinue(self, *args) 673 674 class Decorators(Node): 675 def __init__(self, nodes, lineno=None): 676 Node.__init__(self) 677 self.nodes = nodes 678 self.lineno = lineno 679 680 def getChildren(self): 681 return tuple(flatten(self.nodes)) 682 683 def getChildNodes(self): 684 nodelist = [] 685 nodelist.extend(flatten_nodes(self.nodes)) 686 return tuple(nodelist) 687 688 def __repr__(self): 689 return "Decorators(%r)" % (self.nodes,) 690 691 def __str__(self): 692 return "\n".join([("@%s" % node) for node in self.nodes]) 693 694 def visit(self, visitor, *args): 695 return visitor.visitDecorators(self, *args) 696 697 class Dict(Node): 698 def __init__(self, items, lineno=None): 699 Node.__init__(self) 700 self.items = items 701 self.lineno = lineno 702 703 def getChildren(self): 704 return tuple(flatten(self.items)) 705 706 def getChildNodes(self): 707 nodelist = [] 708 nodelist.extend(flatten_nodes(self.items)) 709 return tuple(nodelist) 710 711 def __repr__(self): 712 return "Dict(%r)" % (self.items,) 713 714 def __str__(self): 715 return "{%s}" % ", ".join([("%s : %s" % (key, value)) for (key, value) in self.items]) 716 717 def visit(self, visitor, *args): 718 return visitor.visitDict(self, *args) 719 720 class Discard(Node): 721 def __init__(self, expr, lineno=None): 722 Node.__init__(self) 723 self.expr = expr 724 self.lineno = lineno 725 726 def getChildren(self): 727 return self.expr, 728 729 def getChildNodes(self): 730 return self.expr, 731 732 def __repr__(self): 733 return "Discard(%r)" % (self.expr,) 734 735 def __str__(self): 736 return str(self.expr) 737 738 def visit(self, visitor, *args): 739 return visitor.visitDiscard(self, *args) 740 741 class Div(Node, OperatorUser): 742 def __init__(self, leftright, lineno=None): 743 Node.__init__(self) 744 OperatorUser.__init__(self) 745 self.left = leftright[0] 746 self.right = leftright[1] 747 self.lineno = lineno 748 749 def getChildren(self): 750 return self.left, self.right 751 752 def getChildNodes(self): 753 return self.left, self.right 754 755 def __repr__(self): 756 return "Div((%r, %r))" % (self.left, self.right) 757 758 def __str__(self): 759 return "(%s / %s)" % (self.left, self.right) 760 761 def visit(self, visitor, *args): 762 return visitor.visitDiv(self, *args) 763 764 class Ellipsis(Node): 765 def __init__(self, lineno=None): 766 Node.__init__(self) 767 self.lineno = lineno 768 769 def getChildren(self): 770 return () 771 772 def getChildNodes(self): 773 return () 774 775 def __repr__(self): 776 return "Ellipsis()" 777 778 def __str__(self): 779 return "..." 780 781 def visit(self, visitor, *args): 782 return visitor.visitEllipsis(self, *args) 783 784 class Exec(Node): 785 def __init__(self, expr, locals, globals, lineno=None): 786 Node.__init__(self) 787 self.expr = expr 788 self.locals = locals 789 self.globals = globals 790 self.lineno = lineno 791 792 def getChildren(self): 793 children = [] 794 children.append(self.expr) 795 children.append(self.locals) 796 children.append(self.globals) 797 return tuple(children) 798 799 def getChildNodes(self): 800 nodelist = [] 801 nodelist.append(self.expr) 802 if self.locals is not None: 803 nodelist.append(self.locals) 804 if self.globals is not None: 805 nodelist.append(self.globals) 806 return tuple(nodelist) 807 808 def __repr__(self): 809 return "Exec(%r, %r, %r)" % (self.expr, self.locals, self.globals) 810 811 def __str__(self): 812 return "exec %s%s%s" % (self.expr, self.locals and "in %s" % self.locals or "", 813 self.globals and ", %s" % self.globals or "") 814 815 def visit(self, visitor, *args): 816 return visitor.visitExec(self, *args) 817 818 class FloorDiv(Node, OperatorUser): 819 def __init__(self, leftright, lineno=None): 820 Node.__init__(self) 821 OperatorUser.__init__(self) 822 self.left = leftright[0] 823 self.right = leftright[1] 824 self.lineno = lineno 825 826 def getChildren(self): 827 return self.left, self.right 828 829 def getChildNodes(self): 830 return self.left, self.right 831 832 def __repr__(self): 833 return "FloorDiv((%r, %r))" % (self.left, self.right) 834 835 def __str__(self): 836 return "(%s // %s)" % (self.left, self.right) 837 838 def visit(self, visitor, *args): 839 return visitor.visitFloorDiv(self, *args) 840 841 class For(Node): 842 def __init__(self, assign, list, body, else_, lineno=None): 843 Node.__init__(self) 844 self.assign = assign 845 self.list = list 846 self.body = body 847 self.else_ = else_ 848 self.lineno = lineno 849 850 def getChildren(self): 851 children = [] 852 children.append(self.assign) 853 children.append(self.list) 854 children.append(self.body) 855 children.append(self.else_) 856 return tuple(children) 857 858 def getChildNodes(self): 859 nodelist = [] 860 nodelist.append(self.assign) 861 nodelist.append(self.list) 862 nodelist.append(self.body) 863 if self.else_ is not None: 864 nodelist.append(self.else_) 865 return tuple(nodelist) 866 867 def __repr__(self): 868 return "For(%r, %r, %r, %r)" % (self.assign, self.list, self.body, self.else_) 869 870 def __str__(self): 871 return "for %s in %s:%s%s" % ( 872 self.assign, self.list, 873 indent("\n%s" % self.body), 874 self.else_ and "\nelse:%s" % indent("\n%s" % self.else_) or "" 875 ) 876 877 def visit(self, visitor, *args): 878 return visitor.visitFor(self, *args) 879 880 class From(Node): 881 def __init__(self, modname, names, level, lineno=None): 882 Node.__init__(self) 883 self.modname = modname 884 self.names = names 885 self.level = level 886 self.lineno = lineno 887 888 def getChildren(self): 889 return self.modname, self.names, self.level 890 891 def getChildNodes(self): 892 return () 893 894 def __repr__(self): 895 return "From(%r, %r, %r)" % (self.modname, self.names, self.level) 896 897 def __str__(self): 898 return "from %s import %s" % (self.modname, 899 ", ".join([(alias and "%s as %s" % (name, alias) or name) for (name, alias) in self.names])) 900 901 def visit(self, visitor, *args): 902 return visitor.visitFrom(self, *args) 903 904 class Function(Node): 905 def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno=None): 906 Node.__init__(self) 907 self.decorators = decorators 908 self.name = name 909 self.argnames = argnames 910 self.defaults = defaults 911 self.flags = flags 912 self.doc = doc 913 self.code = code 914 self.lineno = lineno 915 self.varargs = self.kwargs = None 916 if flags & CO_VARARGS: 917 self.varargs = 1 918 if flags & CO_VARKEYWORDS: 919 self.kwargs = 1 920 921 def getChildren(self): 922 children = [] 923 children.append(self.decorators) 924 children.append(self.name) 925 children.append(self.argnames) 926 children.extend(flatten(self.defaults)) 927 children.append(self.flags) 928 children.append(self.doc) 929 children.append(self.code) 930 return tuple(children) 931 932 def getChildNodes(self): 933 nodelist = [] 934 if self.decorators is not None: 935 nodelist.append(self.decorators) 936 nodelist.extend(flatten_nodes(self.defaults)) 937 nodelist.append(self.code) 938 return tuple(nodelist) 939 940 def __repr__(self): 941 return "Function(%r, %r, %r, %r, %r, %r, %r)" % (self.decorators, self.name, self.argnames, self.defaults, self.flags, self.doc, self.code) 942 943 def __str__(self): 944 parameters = decode_function(self) 945 946 return "%sdef %s(%s):%s%s\n" % ( 947 self.decorators and "%s\n" % "\n".join([("@%s" % decorator) for decorator in self.decorators]) or "", 948 self.name, 949 ", ".join(parameters), 950 self.doc and "\n\n\t%s\n" % docstring(self.doc) or "", 951 indent("\n%s" % self.code) 952 ) 953 954 def visit(self, visitor, *args): 955 return visitor.visitFunction(self, *args) 956 957 class GenExpr(Node): 958 def __init__(self, code, lineno=None): 959 Node.__init__(self) 960 self.code = code 961 self.lineno = lineno 962 self.argnames = ['.0'] 963 self.varargs = self.kwargs = None 964 965 def getChildren(self): 966 return self.code, 967 968 def getChildNodes(self): 969 return self.code, 970 971 def __repr__(self): 972 return "GenExpr(%r)" % (self.code,) 973 974 def __str__(self): 975 return str(self.code) 976 977 def visit(self, visitor, *args): 978 return visitor.visitGenExpr(self, *args) 979 980 class GenExprFor(Node): 981 def __init__(self, assign, iter, ifs, lineno=None): 982 Node.__init__(self) 983 self.assign = assign 984 self.iter = iter 985 self.ifs = ifs 986 self.lineno = lineno 987 self.is_outmost = False 988 989 def getChildren(self): 990 children = [] 991 children.append(self.assign) 992 children.append(self.iter) 993 children.extend(flatten(self.ifs)) 994 return tuple(children) 995 996 def getChildNodes(self): 997 nodelist = [] 998 nodelist.append(self.assign) 999 nodelist.append(self.iter) 1000 nodelist.extend(flatten_nodes(self.ifs)) 1001 return tuple(nodelist) 1002 1003 def __repr__(self): 1004 return "GenExprFor(%r, %r, %r)" % (self.assign, self.iter, self.ifs) 1005 1006 def __str__(self): 1007 return "for %s in %s%s" % ( 1008 self.assign, self.iter, 1009 self.ifs and " ".join(map(str, self.ifs)) or "" 1010 ) 1011 1012 def visit(self, visitor, *args): 1013 return visitor.visitGenExprFor(self, *args) 1014 1015 class GenExprIf(Node): 1016 def __init__(self, test, lineno=None): 1017 Node.__init__(self) 1018 self.test = test 1019 self.lineno = lineno 1020 1021 def getChildren(self): 1022 return self.test, 1023 1024 def getChildNodes(self): 1025 return self.test, 1026 1027 def __repr__(self): 1028 return "GenExprIf(%r)" % (self.test,) 1029 1030 def __str__(self): 1031 return "if %s" % self.test 1032 1033 def visit(self, visitor, *args): 1034 return visitor.visitGenExprIf(self, *args) 1035 1036 class GenExprInner(Node): 1037 def __init__(self, expr, quals, lineno=None): 1038 Node.__init__(self) 1039 self.expr = expr 1040 self.quals = quals 1041 self.lineno = lineno 1042 1043 def getChildren(self): 1044 children = [] 1045 children.append(self.expr) 1046 children.extend(flatten(self.quals)) 1047 return tuple(children) 1048 1049 def getChildNodes(self): 1050 nodelist = [] 1051 nodelist.append(self.expr) 1052 nodelist.extend(flatten_nodes(self.quals)) 1053 return tuple(nodelist) 1054 1055 def __repr__(self): 1056 return "GenExprInner(%r, %r)" % (self.expr, self.quals) 1057 1058 def __str__(self): 1059 return "%s %s" % (self.expr, " ".join(map(str, self.quals))) 1060 1061 def visit(self, visitor, *args): 1062 return visitor.visitGenExprInner(self, *args) 1063 1064 class Getattr(Node, AttributeAccessor): 1065 def __init__(self, expr, attrname, lineno=None): 1066 Node.__init__(self) 1067 AttributeAccessor.__init__(self) 1068 self.expr = expr 1069 self.attrname = attrname 1070 self.lineno = lineno 1071 1072 # Additional annotations. 1073 1074 self._expr = None 1075 1076 def getChildren(self): 1077 return self.expr, self.attrname 1078 1079 def getChildNodes(self): 1080 return self.expr, 1081 1082 def __repr__(self): 1083 return "Getattr(%r, %r)" % (self.expr, self.attrname) 1084 1085 def __str__(self): 1086 return "%s.%s" % (self.expr, self.attrname) 1087 1088 def visit(self, visitor, *args): 1089 return visitor.visitGetattr(self, *args) 1090 1091 class Global(Node): 1092 def __init__(self, names, lineno=None): 1093 Node.__init__(self) 1094 self.names = names 1095 self.lineno = lineno 1096 1097 def getChildren(self): 1098 return self.names, 1099 1100 def getChildNodes(self): 1101 return () 1102 1103 def __repr__(self): 1104 return "Global(%r)" % (self.names,) 1105 1106 def __str__(self): 1107 return "global %s" % ", ".join(map(str, self.names)) 1108 1109 def visit(self, visitor, *args): 1110 return visitor.visitGlobal(self, *args) 1111 1112 class If(Node): 1113 def __init__(self, tests, else_, lineno=None): 1114 Node.__init__(self) 1115 self.tests = tests 1116 self.else_ = else_ 1117 self.lineno = lineno 1118 1119 def getChildren(self): 1120 children = [] 1121 children.extend(flatten(self.tests)) 1122 children.append(self.else_) 1123 return tuple(children) 1124 1125 def getChildNodes(self): 1126 nodelist = [] 1127 nodelist.extend(flatten_nodes(self.tests)) 1128 if self.else_ is not None: 1129 nodelist.append(self.else_) 1130 return tuple(nodelist) 1131 1132 def __repr__(self): 1133 return "If(%r, %r)" % (self.tests, self.else_) 1134 1135 def __str__(self): 1136 tests = [("%sif %s:%s" % (i > 0 and "el" or "", test, indent("\n%s" % body))) for (i, (test, body)) in enumerate(self.tests)] 1137 return "%s%s" % ( 1138 "\n".join(tests), 1139 self.else_ and "\nelse:%s" % indent("\n%s" % self.else_) or "" 1140 ) 1141 1142 def visit(self, visitor, *args): 1143 return visitor.visitIf(self, *args) 1144 1145 class IfExp(Node): 1146 def __init__(self, test, then, else_, lineno=None): 1147 Node.__init__(self) 1148 self.test = test 1149 self.then = then 1150 self.else_ = else_ 1151 self.lineno = lineno 1152 1153 def getChildren(self): 1154 return self.test, self.then, self.else_ 1155 1156 def getChildNodes(self): 1157 return self.test, self.then, self.else_ 1158 1159 def __repr__(self): 1160 return "IfExp(%r, %r, %r)" % (self.test, self.then, self.else_) 1161 1162 def __str__(self): 1163 return "%s if %s else %s" % (self.then, self.test, self.else_) 1164 1165 def visit(self, visitor, *args): 1166 return visitor.visitIfExp(self, *args) 1167 1168 class Import(Node): 1169 def __init__(self, names, lineno=None): 1170 Node.__init__(self) 1171 self.names = names 1172 self.lineno = lineno 1173 1174 def getChildren(self): 1175 return self.names, 1176 1177 def getChildNodes(self): 1178 return () 1179 1180 def __repr__(self): 1181 return "Import(%r)" % (self.names,) 1182 1183 def __str__(self): 1184 return "import %s" % ( 1185 ", ".join([(alias and "%s as %s" % (name, alias) or name) for (name, alias) in self.names])) 1186 1187 def visit(self, visitor, *args): 1188 return visitor.visitImport(self, *args) 1189 1190 class Invert(Node, OperatorUser): 1191 def __init__(self, expr, lineno=None): 1192 Node.__init__(self) 1193 OperatorUser.__init__(self) 1194 self.expr = expr 1195 self.lineno = lineno 1196 1197 def getChildren(self): 1198 return self.expr, 1199 1200 def getChildNodes(self): 1201 return self.expr, 1202 1203 def __repr__(self): 1204 return "Invert(%r)" % (self.expr,) 1205 1206 def __str__(self): 1207 return "~%s" % self.expr 1208 1209 def visit(self, visitor, *args): 1210 return visitor.visitInvert(self, *args) 1211 1212 class Keyword(Node): 1213 def __init__(self, name, expr, lineno=None): 1214 Node.__init__(self) 1215 self.name = name 1216 self.expr = expr 1217 self.lineno = lineno 1218 1219 def getChildren(self): 1220 return self.name, self.expr 1221 1222 def getChildNodes(self): 1223 return self.expr, 1224 1225 def __repr__(self): 1226 return "Keyword(%r, %r)" % (self.name, self.expr) 1227 1228 def __str__(self): 1229 return "%s=%s" % (self.name, self.expr) 1230 1231 def visit(self, visitor, *args): 1232 return visitor.visitKeyword(self, *args) 1233 1234 class Lambda(Node): 1235 def __init__(self, argnames, defaults, flags, code, lineno=None): 1236 Node.__init__(self) 1237 self.argnames = argnames 1238 self.defaults = defaults 1239 self.flags = flags 1240 self.code = code 1241 self.lineno = lineno 1242 self.varargs = self.kwargs = None 1243 if flags & CO_VARARGS: 1244 self.varargs = 1 1245 if flags & CO_VARKEYWORDS: 1246 self.kwargs = 1 1247 1248 def getChildren(self): 1249 children = [] 1250 children.append(self.argnames) 1251 children.extend(flatten(self.defaults)) 1252 children.append(self.flags) 1253 children.append(self.code) 1254 return tuple(children) 1255 1256 def getChildNodes(self): 1257 nodelist = [] 1258 nodelist.extend(flatten_nodes(self.defaults)) 1259 nodelist.append(self.code) 1260 return tuple(nodelist) 1261 1262 def __repr__(self): 1263 return "Lambda(%r, %r, %r, %r)" % (self.argnames, self.defaults, self.flags, self.code) 1264 1265 def __str__(self): 1266 parameters = decode_function(self) 1267 return "lambda %s: %s" % (", ".join(parameters), self.code) 1268 1269 def visit(self, visitor, *args): 1270 return visitor.visitLambda(self, *args) 1271 1272 class LeftShift(Node, OperatorUser): 1273 def __init__(self, leftright, lineno=None): 1274 Node.__init__(self) 1275 OperatorUser.__init__(self) 1276 self.left = leftright[0] 1277 self.right = leftright[1] 1278 self.lineno = lineno 1279 1280 def getChildren(self): 1281 return self.left, self.right 1282 1283 def getChildNodes(self): 1284 return self.left, self.right 1285 1286 def __repr__(self): 1287 return "LeftShift((%r, %r))" % (self.left, self.right) 1288 1289 def __str__(self): 1290 return "(%s << %s)" % (self.left, self.right) 1291 1292 def visit(self, visitor, *args): 1293 return visitor.visitLeftShift(self, *args) 1294 1295 class List(Node): 1296 def __init__(self, nodes, lineno=None): 1297 Node.__init__(self) 1298 self.nodes = nodes 1299 self.lineno = lineno 1300 1301 def getChildren(self): 1302 return tuple(flatten(self.nodes)) 1303 1304 def getChildNodes(self): 1305 nodelist = [] 1306 nodelist.extend(flatten_nodes(self.nodes)) 1307 return tuple(nodelist) 1308 1309 def __repr__(self): 1310 return "List(%r)" % (self.nodes,) 1311 1312 def __str__(self): 1313 return "[%s]" % ", ".join(map(str, self.nodes)) 1314 1315 def visit(self, visitor, *args): 1316 return visitor.visitList(self, *args) 1317 1318 class ListComp(Node): 1319 def __init__(self, expr, quals, lineno=None): 1320 Node.__init__(self) 1321 self.expr = expr 1322 self.quals = quals 1323 self.lineno = lineno 1324 1325 def getChildren(self): 1326 children = [] 1327 children.append(self.expr) 1328 children.extend(flatten(self.quals)) 1329 return tuple(children) 1330 1331 def getChildNodes(self): 1332 nodelist = [] 1333 nodelist.append(self.expr) 1334 nodelist.extend(flatten_nodes(self.quals)) 1335 return tuple(nodelist) 1336 1337 def __repr__(self): 1338 return "ListComp(%r, %r)" % (self.expr, self.quals) 1339 1340 def __str__(self): 1341 return "[%s %s]" % (self.expr, " ".join(map(str, self.quals))) 1342 1343 def visit(self, visitor, *args): 1344 return visitor.visitListComp(self, *args) 1345 1346 class ListCompFor(Node): 1347 def __init__(self, assign, list, ifs, lineno=None): 1348 Node.__init__(self) 1349 self.assign = assign 1350 self.list = list 1351 self.ifs = ifs 1352 self.lineno = lineno 1353 1354 def getChildren(self): 1355 children = [] 1356 children.append(self.assign) 1357 children.append(self.list) 1358 children.extend(flatten(self.ifs)) 1359 return tuple(children) 1360 1361 def getChildNodes(self): 1362 nodelist = [] 1363 nodelist.append(self.assign) 1364 nodelist.append(self.list) 1365 nodelist.extend(flatten_nodes(self.ifs)) 1366 return tuple(nodelist) 1367 1368 def __repr__(self): 1369 return "ListCompFor(%r, %r, %r)" % (self.assign, self.list, self.ifs) 1370 1371 def __str__(self): 1372 return "for %s in %s%s" % ( 1373 self.assign, self.list, 1374 self.ifs and " ".join(map(str, self.ifs)) or "" 1375 ) 1376 1377 def visit(self, visitor, *args): 1378 return visitor.visitListCompFor(self, *args) 1379 1380 class ListCompIf(Node): 1381 def __init__(self, test, lineno=None): 1382 Node.__init__(self) 1383 self.test = test 1384 self.lineno = lineno 1385 1386 def getChildren(self): 1387 return self.test, 1388 1389 def getChildNodes(self): 1390 return self.test, 1391 1392 def __repr__(self): 1393 return "ListCompIf(%r)" % (self.test,) 1394 1395 def __str__(self): 1396 return " if %s" % self.test 1397 1398 def visit(self, visitor, *args): 1399 return visitor.visitListCompIf(self, *args) 1400 1401 class Mod(Node, OperatorUser): 1402 def __init__(self, leftright, lineno=None): 1403 Node.__init__(self) 1404 OperatorUser.__init__(self) 1405 self.left = leftright[0] 1406 self.right = leftright[1] 1407 self.lineno = lineno 1408 1409 def getChildren(self): 1410 return self.left, self.right 1411 1412 def getChildNodes(self): 1413 return self.left, self.right 1414 1415 def __repr__(self): 1416 return "Mod((%r, %r))" % (self.left, self.right) 1417 1418 def __str__(self): 1419 return "(%s %% %s)" % (self.left, self.right) 1420 1421 def visit(self, visitor, *args): 1422 return visitor.visitMod(self, *args) 1423 1424 class Module(Node): 1425 def __init__(self, doc, node, lineno=None): 1426 Node.__init__(self) 1427 self.doc = doc 1428 self.node = node 1429 self.lineno = lineno 1430 1431 def getChildren(self): 1432 return self.doc, self.node 1433 1434 def getChildNodes(self): 1435 return self.node, 1436 1437 def __repr__(self): 1438 return "Module(%r, %r)" % (self.doc, self.node) 1439 1440 def __str__(self): 1441 return "%s%s" % (self.doc and "%s\n\n" % docstring(self.doc) or "", self.node) 1442 1443 def visit(self, visitor, *args): 1444 return visitor.visitModule(self, *args) 1445 1446 class Mul(Node, OperatorUser): 1447 def __init__(self, leftright, lineno=None): 1448 Node.__init__(self) 1449 OperatorUser.__init__(self) 1450 self.left = leftright[0] 1451 self.right = leftright[1] 1452 self.lineno = lineno 1453 1454 def getChildren(self): 1455 return self.left, self.right 1456 1457 def getChildNodes(self): 1458 return self.left, self.right 1459 1460 def __repr__(self): 1461 return "Mul((%r, %r))" % (self.left, self.right) 1462 1463 def __str__(self): 1464 return "(%s * %s)" % (self.left, self.right) 1465 1466 def visit(self, visitor, *args): 1467 return visitor.visitMul(self, *args) 1468 1469 class Name(Node, AttributeAccessor): 1470 def __init__(self, name, lineno=None): 1471 Node.__init__(self) 1472 AttributeAccessor.__init__(self) 1473 self.name = name 1474 self.lineno = lineno 1475 1476 # Additional annotations. 1477 1478 self._scope = None 1479 1480 def getChildren(self): 1481 return self.name, 1482 1483 def getChildNodes(self): 1484 return () 1485 1486 def __repr__(self): 1487 return "Name(%r)" % (self.name,) 1488 1489 def __str__(self): 1490 return str(self.name) 1491 1492 def visit(self, visitor, *args): 1493 return visitor.visitName(self, *args) 1494 1495 class Not(Node): 1496 def __init__(self, expr, lineno=None): 1497 Node.__init__(self) 1498 self.expr = expr 1499 self.lineno = lineno 1500 1501 def getChildren(self): 1502 return self.expr, 1503 1504 def getChildNodes(self): 1505 return self.expr, 1506 1507 def __repr__(self): 1508 return "Not(%r)" % (self.expr,) 1509 1510 def __str__(self): 1511 return "not %s" % self.expr 1512 1513 def visit(self, visitor, *args): 1514 return visitor.visitNot(self, *args) 1515 1516 class Or(Node): 1517 def __init__(self, nodes, lineno=None): 1518 Node.__init__(self) 1519 self.nodes = nodes 1520 self.lineno = lineno 1521 1522 def getChildren(self): 1523 return tuple(flatten(self.nodes)) 1524 1525 def getChildNodes(self): 1526 nodelist = [] 1527 nodelist.extend(flatten_nodes(self.nodes)) 1528 return tuple(nodelist) 1529 1530 def __repr__(self): 1531 return "Or(%r)" % (self.nodes,) 1532 1533 def __str__(self): 1534 return "(%s)" % " or ".join(map(str, self.nodes)) 1535 1536 def visit(self, visitor, *args): 1537 return visitor.visitOr(self, *args) 1538 1539 class Pass(Node): 1540 def __init__(self, lineno=None): 1541 Node.__init__(self) 1542 self.lineno = lineno 1543 1544 def getChildren(self): 1545 return () 1546 1547 def getChildNodes(self): 1548 return () 1549 1550 def __repr__(self): 1551 return "Pass()" 1552 1553 def __str__(self): 1554 return "pass" 1555 1556 def visit(self, visitor, *args): 1557 return visitor.visitPass(self, *args) 1558 1559 class Power(Node, OperatorUser): 1560 def __init__(self, leftright, lineno=None): 1561 Node.__init__(self) 1562 OperatorUser.__init__(self) 1563 self.left = leftright[0] 1564 self.right = leftright[1] 1565 self.lineno = lineno 1566 1567 def getChildren(self): 1568 return self.left, self.right 1569 1570 def getChildNodes(self): 1571 return self.left, self.right 1572 1573 def __repr__(self): 1574 return "Power((%r, %r))" % (self.left, self.right) 1575 1576 def __str__(self): 1577 return "(%s ** %s)" % (self.left, self.right) 1578 1579 def visit(self, visitor, *args): 1580 return visitor.visitPower(self, *args) 1581 1582 class Print(Node): 1583 def __init__(self, nodes, dest, lineno=None): 1584 Node.__init__(self) 1585 self.nodes = nodes 1586 self.dest = dest 1587 self.lineno = lineno 1588 1589 def getChildren(self): 1590 children = [] 1591 children.extend(flatten(self.nodes)) 1592 children.append(self.dest) 1593 return tuple(children) 1594 1595 def getChildNodes(self): 1596 nodelist = [] 1597 nodelist.extend(flatten_nodes(self.nodes)) 1598 if self.dest is not None: 1599 nodelist.append(self.dest) 1600 return tuple(nodelist) 1601 1602 def __repr__(self): 1603 return "Print(%r, %r)" % (self.nodes, self.dest) 1604 1605 def __str__(self): 1606 dest = self.dest and [">>%s" % self.dest] or [] 1607 return "print %s," % ", ".join(map(str, dest + self.nodes)) 1608 1609 def visit(self, visitor, *args): 1610 return visitor.visitPrint(self, *args) 1611 1612 class Printnl(Node): 1613 def __init__(self, nodes, dest, lineno=None): 1614 Node.__init__(self) 1615 self.nodes = nodes 1616 self.dest = dest 1617 self.lineno = lineno 1618 1619 def getChildren(self): 1620 children = [] 1621 children.extend(flatten(self.nodes)) 1622 children.append(self.dest) 1623 return tuple(children) 1624 1625 def getChildNodes(self): 1626 nodelist = [] 1627 nodelist.extend(flatten_nodes(self.nodes)) 1628 if self.dest is not None: 1629 nodelist.append(self.dest) 1630 return tuple(nodelist) 1631 1632 def __repr__(self): 1633 return "Printnl(%r, %r)" % (self.nodes, self.dest) 1634 1635 def __str__(self): 1636 dest = self.dest and [">>%s" % self.dest] or [] 1637 return "print %s" % ", ".join(map(str, dest + self.nodes)) 1638 1639 def visit(self, visitor, *args): 1640 return visitor.visitPrintnl(self, *args) 1641 1642 class Raise(Node): 1643 def __init__(self, expr1, expr2, expr3, lineno=None): 1644 Node.__init__(self) 1645 self.expr1 = expr1 1646 self.expr2 = expr2 1647 self.expr3 = expr3 1648 self.lineno = lineno 1649 1650 def getChildren(self): 1651 children = [] 1652 children.append(self.expr1) 1653 children.append(self.expr2) 1654 children.append(self.expr3) 1655 return tuple(children) 1656 1657 def getChildNodes(self): 1658 nodelist = [] 1659 if self.expr1 is not None: 1660 nodelist.append(self.expr1) 1661 if self.expr2 is not None: 1662 nodelist.append(self.expr2) 1663 if self.expr3 is not None: 1664 nodelist.append(self.expr3) 1665 return tuple(nodelist) 1666 1667 def __repr__(self): 1668 return "Raise(%r, %r, %r)" % (self.expr1, self.expr2, self.expr3) 1669 1670 def __str__(self): 1671 args = self.expr1 and [self.expr1] or [] 1672 args += self.expr2 and [self.expr2] or [] 1673 args += self.expr3 and [self.expr3] or [] 1674 return "raise %s" % ", ".join(map(str, args)) 1675 1676 def visit(self, visitor, *args): 1677 return visitor.visitRaise(self, *args) 1678 1679 class Return(Node): 1680 def __init__(self, value, lineno=None): 1681 Node.__init__(self) 1682 self.value = value 1683 self.lineno = lineno 1684 1685 def getChildren(self): 1686 return self.value, 1687 1688 def getChildNodes(self): 1689 return self.value, 1690 1691 def __repr__(self): 1692 return "Return(%r)" % (self.value,) 1693 1694 def __str__(self): 1695 return "return %s" % self.value 1696 1697 def visit(self, visitor, *args): 1698 return visitor.visitReturn(self, *args) 1699 1700 class RightShift(Node, OperatorUser): 1701 def __init__(self, leftright, lineno=None): 1702 Node.__init__(self) 1703 OperatorUser.__init__(self) 1704 self.left = leftright[0] 1705 self.right = leftright[1] 1706 self.lineno = lineno 1707 1708 def getChildren(self): 1709 return self.left, self.right 1710 1711 def getChildNodes(self): 1712 return self.left, self.right 1713 1714 def __repr__(self): 1715 return "RightShift((%r, %r))" % (self.left, self.right) 1716 1717 def __str__(self): 1718 return "(%s >> %s)" % (self.left, self.right) 1719 1720 def visit(self, visitor, *args): 1721 return visitor.visitRightShift(self, *args) 1722 1723 class Slice(Node, OperatorUser): 1724 def __init__(self, expr, flags, lower, upper, lineno=None): 1725 Node.__init__(self) 1726 OperatorUser.__init__(self) 1727 self.expr = expr 1728 self.flags = flags 1729 self.lower = lower 1730 self.upper = upper 1731 self.lineno = lineno 1732 1733 def getChildren(self): 1734 children = [] 1735 children.append(self.expr) 1736 children.append(self.flags) 1737 children.append(self.lower) 1738 children.append(self.upper) 1739 return tuple(children) 1740 1741 def getChildNodes(self): 1742 nodelist = [] 1743 nodelist.append(self.expr) 1744 if self.lower is not None: 1745 nodelist.append(self.lower) 1746 if self.upper is not None: 1747 nodelist.append(self.upper) 1748 return tuple(nodelist) 1749 1750 def __repr__(self): 1751 return "Slice(%r, %r, %r, %r)" % (self.expr, self.flags, self.lower, self.upper) 1752 1753 def __str__(self): 1754 args = [] 1755 args = self.lower is not None and [self.lower] or [] 1756 args = self.upper is not None and [self.upper] or [] 1757 return "%s[%s]" % (self.expr, ":".join(map(str, args))) 1758 1759 def visit(self, visitor, *args): 1760 return visitor.visitSlice(self, *args) 1761 1762 class Sliceobj(Node): 1763 def __init__(self, nodes, lineno=None): 1764 Node.__init__(self) 1765 self.nodes = nodes 1766 self.lineno = lineno 1767 1768 def getChildren(self): 1769 return tuple(flatten(self.nodes)) 1770 1771 def getChildNodes(self): 1772 nodelist = [] 1773 nodelist.extend(flatten_nodes(self.nodes)) 1774 return tuple(nodelist) 1775 1776 def __repr__(self): 1777 return "Sliceobj(%r)" % (self.nodes,) 1778 1779 def __str__(self): 1780 return ":".join(map(str, self.nodes)) 1781 1782 def visit(self, visitor, *args): 1783 return visitor.visitSliceobj(self, *args) 1784 1785 class Stmt(Node): 1786 def __init__(self, nodes, lineno=None): 1787 Node.__init__(self) 1788 self.nodes = nodes 1789 self.lineno = lineno 1790 1791 def getChildren(self): 1792 return tuple(flatten(self.nodes)) 1793 1794 def getChildNodes(self): 1795 nodelist = [] 1796 nodelist.extend(flatten_nodes(self.nodes)) 1797 return tuple(nodelist) 1798 1799 def __repr__(self): 1800 return "Stmt(%r)" % (self.nodes,) 1801 1802 def __str__(self): 1803 return "\n".join(map(str, flatten_statement(self.nodes))) 1804 1805 def visit(self, visitor, *args): 1806 return visitor.visitStmt(self, *args) 1807 1808 class Sub(Node, OperatorUser): 1809 def __init__(self, leftright, lineno=None): 1810 Node.__init__(self) 1811 OperatorUser.__init__(self) 1812 self.left = leftright[0] 1813 self.right = leftright[1] 1814 self.lineno = lineno 1815 1816 def getChildren(self): 1817 return self.left, self.right 1818 1819 def getChildNodes(self): 1820 return self.left, self.right 1821 1822 def __repr__(self): 1823 return "Sub((%r, %r))" % (self.left, self.right) 1824 1825 def __str__(self): 1826 return "(%s - %s)" % (self.left, self.right) 1827 1828 def visit(self, visitor, *args): 1829 return visitor.visitSub(self, *args) 1830 1831 class Subscript(Node, AttributeAccessor, OperatorUser): 1832 def __init__(self, expr, flags, subs, lineno=None): 1833 Node.__init__(self) 1834 AttributeAccessor.__init__(self) 1835 OperatorUser.__init__(self) 1836 self.expr = expr 1837 self.flags = flags 1838 self.subs = subs 1839 self.lineno = lineno 1840 1841 # Additional annotations. 1842 1843 self._expr = None 1844 1845 def getChildren(self): 1846 children = [] 1847 children.append(self.expr) 1848 children.append(self.flags) 1849 children.extend(flatten(self.subs)) 1850 return tuple(children) 1851 1852 def getChildNodes(self): 1853 nodelist = [] 1854 nodelist.append(self.expr) 1855 nodelist.extend(flatten_nodes(self.subs)) 1856 return tuple(nodelist) 1857 1858 def __repr__(self): 1859 return "Subscript(%r, %r, %r)" % (self.expr, self.flags, self.subs) 1860 1861 def __str__(self): 1862 return "%s[%s]" % (self.expr, ",".join(map(str, self.subs))) 1863 1864 def visit(self, visitor, *args): 1865 return visitor.visitSubscript(self, *args) 1866 1867 class TryExcept(Node): 1868 def __init__(self, body, handlers, else_, lineno=None): 1869 Node.__init__(self) 1870 self.body = body 1871 self.handlers = handlers 1872 self.else_ = else_ 1873 self.lineno = lineno 1874 1875 def getChildren(self): 1876 children = [] 1877 children.append(self.body) 1878 children.extend(flatten(self.handlers)) 1879 children.append(self.else_) 1880 return tuple(children) 1881 1882 def getChildNodes(self): 1883 nodelist = [] 1884 nodelist.append(self.body) 1885 nodelist.extend(flatten_nodes(self.handlers)) 1886 if self.else_ is not None: 1887 nodelist.append(self.else_) 1888 return tuple(nodelist) 1889 1890 def __repr__(self): 1891 return "TryExcept(%r, %r, %r)" % (self.body, self.handlers, self.else_) 1892 1893 def __str__(self): 1894 handlers = [ 1895 ("\nexcept%s%s:%s" % (spec and " %s" % spec or "", assign and ", %s" % assign or "", indent("\n%s" % statement))) 1896 for (spec, assign, statement) in self.handlers 1897 ] 1898 1899 return "try:%s%s%s" % ( 1900 indent("\n%s" % self.body), 1901 "".join(handlers), 1902 self.else_ and "\nelse:%s" % indent("\n%s" % self.else_) or "" 1903 ) 1904 1905 def visit(self, visitor, *args): 1906 return visitor.visitTryExcept(self, *args) 1907 1908 class TryFinally(Node): 1909 def __init__(self, body, final, lineno=None): 1910 Node.__init__(self) 1911 self.body = body 1912 self.final = final 1913 self.lineno = lineno 1914 1915 def getChildren(self): 1916 return self.body, self.final 1917 1918 def getChildNodes(self): 1919 return self.body, self.final 1920 1921 def __repr__(self): 1922 return "TryFinally(%r, %r)" % (self.body, self.final) 1923 1924 def __str__(self): 1925 return "try:%s\nfinally:%s" % ( 1926 indent("\n%s" % self.body), 1927 indent("\n%s" % self.final) 1928 ) 1929 1930 def visit(self, visitor, *args): 1931 return visitor.visitTryFinally(self, *args) 1932 1933 class Tuple(Node): 1934 def __init__(self, nodes, lineno=None): 1935 Node.__init__(self) 1936 self.nodes = nodes 1937 self.lineno = lineno 1938 1939 def getChildren(self): 1940 return tuple(flatten(self.nodes)) 1941 1942 def getChildNodes(self): 1943 nodelist = [] 1944 nodelist.extend(flatten_nodes(self.nodes)) 1945 return tuple(nodelist) 1946 1947 def __repr__(self): 1948 return "Tuple(%r)" % (self.nodes,) 1949 1950 def __str__(self): 1951 return "(%s)" % ", ".join(map(str, self.nodes)) 1952 1953 def visit(self, visitor, *args): 1954 return visitor.visitTuple(self, *args) 1955 1956 class UnaryAdd(Node, OperatorUser): 1957 def __init__(self, expr, lineno=None): 1958 Node.__init__(self) 1959 OperatorUser.__init__(self) 1960 self.expr = expr 1961 self.lineno = lineno 1962 1963 def getChildren(self): 1964 return self.expr, 1965 1966 def getChildNodes(self): 1967 return self.expr, 1968 1969 def __repr__(self): 1970 return "UnaryAdd(%r)" % (self.expr,) 1971 1972 def __str__(self): 1973 return "+%s" % self.expr 1974 1975 def visit(self, visitor, *args): 1976 return visitor.visitUnaryAdd(self, *args) 1977 1978 class UnarySub(Node, OperatorUser): 1979 def __init__(self, expr, lineno=None): 1980 Node.__init__(self) 1981 OperatorUser.__init__(self) 1982 self.expr = expr 1983 self.lineno = lineno 1984 1985 def getChildren(self): 1986 return self.expr, 1987 1988 def getChildNodes(self): 1989 return self.expr, 1990 1991 def __repr__(self): 1992 return "UnarySub(%r)" % (self.expr,) 1993 1994 def __str__(self): 1995 return "-%s" % self.expr 1996 1997 def visit(self, visitor, *args): 1998 return visitor.visitUnarySub(self, *args) 1999 2000 class While(Node): 2001 def __init__(self, test, body, else_, lineno=None): 2002 Node.__init__(self) 2003 self.test = test 2004 self.body = body 2005 self.else_ = else_ 2006 self.lineno = lineno 2007 2008 def getChildren(self): 2009 children = [] 2010 children.append(self.test) 2011 children.append(self.body) 2012 children.append(self.else_) 2013 return tuple(children) 2014 2015 def getChildNodes(self): 2016 nodelist = [] 2017 nodelist.append(self.test) 2018 nodelist.append(self.body) 2019 if self.else_ is not None: 2020 nodelist.append(self.else_) 2021 return tuple(nodelist) 2022 2023 def __repr__(self): 2024 return "While(%r, %r, %r)" % (self.test, self.body, self.else_) 2025 2026 def __str__(self): 2027 return "while %s:%s%s" % ( 2028 self.test, 2029 indent("\n%s" % self.body), 2030 self.else_ and "\nelse:%s" % indent("\n%s" % self.else_) or "" 2031 ) 2032 2033 def visit(self, visitor, *args): 2034 return visitor.visitWhile(self, *args) 2035 2036 class With(Node): 2037 def __init__(self, expr, vars, body, lineno=None): 2038 Node.__init__(self) 2039 self.expr = expr 2040 self.vars = vars 2041 self.body = body 2042 self.lineno = lineno 2043 2044 def getChildren(self): 2045 children = [] 2046 children.append(self.expr) 2047 children.append(self.vars) 2048 children.append(self.body) 2049 return tuple(children) 2050 2051 def getChildNodes(self): 2052 nodelist = [] 2053 nodelist.append(self.expr) 2054 if self.vars is not None: 2055 nodelist.append(self.vars) 2056 nodelist.append(self.body) 2057 return tuple(nodelist) 2058 2059 def __repr__(self): 2060 return "With(%r, %r, %r)" % (self.expr, self.vars, self.body) 2061 2062 def __str__(self): 2063 return "with %s%s:%s" % ( 2064 self.expr, 2065 self.vars and " as %s" % ", ".join(map(str, self.vars)), 2066 indent("\n%s" % self.body), 2067 ) 2068 2069 def visit(self, visitor, *args): 2070 return visitor.visitWith(self, *args) 2071 2072 class Yield(Node): 2073 def __init__(self, value, lineno=None): 2074 Node.__init__(self) 2075 self.value = value 2076 self.lineno = lineno 2077 2078 def getChildren(self): 2079 return self.value, 2080 2081 def getChildNodes(self): 2082 return self.value, 2083 2084 def __repr__(self): 2085 return "Yield(%r)" % (self.value,) 2086 2087 def __str__(self): 2088 return "yield %s" % self.value 2089 2090 def visit(self, visitor, *args): 2091 return visitor.visitYield(self, *args) 2092 2093 for name, obj in globals().items(): 2094 if isinstance(obj, type) and issubclass(obj, Node): 2095 nodes[name.lower()] = obj