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