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