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