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