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