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([("%s : %s" % (key, value)) for (key, value) in 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 SetComp(Node): 1350 def __init__(self, expr, quals, lineno=None): 1351 self.expr = expr 1352 self.quals = quals 1353 self.lineno = lineno 1354 1355 def getChildren(self): 1356 children = [] 1357 children.append(self.expr) 1358 children.extend(flatten(self.quals)) 1359 return tuple(children) 1360 1361 def getChildNodes(self): 1362 nodelist = [] 1363 nodelist.append(self.expr) 1364 nodelist.extend(flatten_nodes(self.quals)) 1365 return tuple(nodelist) 1366 1367 def __repr__(self): 1368 return "SetComp(%r, %r)" % (self.expr, self.quals) 1369 1370 def __str__(self): 1371 return "{%s %s}" % (self.expr, " ".join(map(str, self.quals))) 1372 1373 def visit(self, visitor, *args): 1374 return visitor.visitSetComp(self, *args) 1375 1376 class DictComp(Node): 1377 def __init__(self, key, value, quals, lineno=None): 1378 self.key = key 1379 self.value = value 1380 self.quals = quals 1381 self.lineno = lineno 1382 1383 def getChildren(self): 1384 children = [] 1385 children.append(self.key) 1386 children.append(self.value) 1387 children.extend(flatten(self.quals)) 1388 return tuple(children) 1389 1390 def getChildNodes(self): 1391 nodelist = [] 1392 nodelist.append(self.key) 1393 nodelist.append(self.value) 1394 nodelist.extend(flatten_nodes(self.quals)) 1395 return tuple(nodelist) 1396 1397 def __repr__(self): 1398 return "DictComp(%r, %r, %r)" % (self.key, self.value, self.quals) 1399 1400 def __str__(self): 1401 return "{%s : %s %s}" % (self.key, self.value, " ".join(map(str, self.quals))) 1402 1403 def visit(self, visitor, *args): 1404 return visitor.visitDictComp(self, *args) 1405 1406 class Mod(Node, OperatorUser): 1407 def __init__(self, leftright, lineno=None): 1408 Node.__init__(self) 1409 OperatorUser.__init__(self) 1410 self.left = leftright[0] 1411 self.right = leftright[1] 1412 self.lineno = lineno 1413 1414 def getChildren(self): 1415 return self.left, self.right 1416 1417 def getChildNodes(self): 1418 return self.left, self.right 1419 1420 def __repr__(self): 1421 return "Mod((%r, %r))" % (self.left, self.right) 1422 1423 def __str__(self): 1424 return "(%s %% %s)" % (self.left, self.right) 1425 1426 def visit(self, visitor, *args): 1427 return visitor.visitMod(self, *args) 1428 1429 class Module(Node): 1430 def __init__(self, doc, node, lineno=None): 1431 Node.__init__(self) 1432 self.doc = doc 1433 self.node = node 1434 self.lineno = lineno 1435 1436 # Additional annotations. 1437 1438 self.unit = None 1439 1440 def getChildren(self): 1441 return self.doc, self.node 1442 1443 def getChildNodes(self): 1444 return self.node, 1445 1446 def __repr__(self): 1447 return "Module(%r, %r)" % (self.doc, self.node) 1448 1449 def __str__(self): 1450 return "%s%s" % (self.doc and "%r\n" % self.doc or "", self.node) 1451 1452 def visit(self, visitor, *args): 1453 return visitor.visitModule(self, *args) 1454 1455 class Mul(Node, OperatorUser): 1456 def __init__(self, leftright, lineno=None): 1457 Node.__init__(self) 1458 OperatorUser.__init__(self) 1459 self.left = leftright[0] 1460 self.right = leftright[1] 1461 self.lineno = lineno 1462 1463 def getChildren(self): 1464 return self.left, self.right 1465 1466 def getChildNodes(self): 1467 return self.left, self.right 1468 1469 def __repr__(self): 1470 return "Mul((%r, %r))" % (self.left, self.right) 1471 1472 def __str__(self): 1473 return "(%s * %s)" % (self.left, self.right) 1474 1475 def visit(self, visitor, *args): 1476 return visitor.visitMul(self, *args) 1477 1478 class Name(Node): 1479 def __init__(self, name, lineno=None): 1480 Node.__init__(self) 1481 self.name = name 1482 self.lineno = lineno 1483 1484 # Additional annotations. 1485 1486 self._scope = None 1487 self._attr = None 1488 self._attrusers = None 1489 self._username = None 1490 1491 def getChildren(self): 1492 return self.name, 1493 1494 def getChildNodes(self): 1495 return () 1496 1497 def __repr__(self): 1498 return "Name(%r)" % (self.name,) 1499 1500 def __str__(self): 1501 return str(self.name) 1502 1503 def visit(self, visitor, *args): 1504 return visitor.visitName(self, *args) 1505 1506 class Not(Node): 1507 def __init__(self, expr, lineno=None): 1508 Node.__init__(self) 1509 self.expr = expr 1510 self.lineno = lineno 1511 1512 def getChildren(self): 1513 return self.expr, 1514 1515 def getChildNodes(self): 1516 return self.expr, 1517 1518 def __repr__(self): 1519 return "Not(%r)" % (self.expr,) 1520 1521 def __str__(self): 1522 return "not %s" % self.expr 1523 1524 def visit(self, visitor, *args): 1525 return visitor.visitNot(self, *args) 1526 1527 class Or(Node): 1528 def __init__(self, nodes, lineno=None): 1529 Node.__init__(self) 1530 self.nodes = nodes 1531 self.lineno = lineno 1532 1533 def getChildren(self): 1534 return tuple(flatten(self.nodes)) 1535 1536 def getChildNodes(self): 1537 nodelist = [] 1538 nodelist.extend(flatten_nodes(self.nodes)) 1539 return tuple(nodelist) 1540 1541 def __repr__(self): 1542 return "Or(%r)" % (self.nodes,) 1543 1544 def __str__(self): 1545 return "(%s)" % " or ".join(map(str, self.nodes)) 1546 1547 def visit(self, visitor, *args): 1548 return visitor.visitOr(self, *args) 1549 1550 class Pass(Node): 1551 def __init__(self, lineno=None): 1552 Node.__init__(self) 1553 self.lineno = lineno 1554 1555 def getChildren(self): 1556 return () 1557 1558 def getChildNodes(self): 1559 return () 1560 1561 def __repr__(self): 1562 return "Pass()" 1563 1564 def __str__(self): 1565 return "pass" 1566 1567 def visit(self, visitor, *args): 1568 return visitor.visitPass(self, *args) 1569 1570 class Power(Node, OperatorUser): 1571 def __init__(self, leftright, lineno=None): 1572 Node.__init__(self) 1573 OperatorUser.__init__(self) 1574 self.left = leftright[0] 1575 self.right = leftright[1] 1576 self.lineno = lineno 1577 1578 def getChildren(self): 1579 return self.left, self.right 1580 1581 def getChildNodes(self): 1582 return self.left, self.right 1583 1584 def __repr__(self): 1585 return "Power((%r, %r))" % (self.left, self.right) 1586 1587 def __str__(self): 1588 return "(%s ** %s)" % (self.left, self.right) 1589 1590 def visit(self, visitor, *args): 1591 return visitor.visitPower(self, *args) 1592 1593 class Print(Node): 1594 def __init__(self, nodes, dest, lineno=None): 1595 Node.__init__(self) 1596 self.nodes = nodes 1597 self.dest = dest 1598 self.lineno = lineno 1599 1600 def getChildren(self): 1601 children = [] 1602 children.extend(flatten(self.nodes)) 1603 children.append(self.dest) 1604 return tuple(children) 1605 1606 def getChildNodes(self): 1607 nodelist = [] 1608 nodelist.extend(flatten_nodes(self.nodes)) 1609 if self.dest is not None: 1610 nodelist.append(self.dest) 1611 return tuple(nodelist) 1612 1613 def __repr__(self): 1614 return "Print(%r, %r)" % (self.nodes, self.dest) 1615 1616 def __str__(self): 1617 dest = self.dest and [">>%s" % self.dest] or [] 1618 return "print %s," % ", ".join(map(str, dest + self.nodes)) 1619 1620 def visit(self, visitor, *args): 1621 return visitor.visitPrint(self, *args) 1622 1623 class Printnl(Node): 1624 def __init__(self, nodes, dest, lineno=None): 1625 Node.__init__(self) 1626 self.nodes = nodes 1627 self.dest = dest 1628 self.lineno = lineno 1629 1630 def getChildren(self): 1631 children = [] 1632 children.extend(flatten(self.nodes)) 1633 children.append(self.dest) 1634 return tuple(children) 1635 1636 def getChildNodes(self): 1637 nodelist = [] 1638 nodelist.extend(flatten_nodes(self.nodes)) 1639 if self.dest is not None: 1640 nodelist.append(self.dest) 1641 return tuple(nodelist) 1642 1643 def __repr__(self): 1644 return "Printnl(%r, %r)" % (self.nodes, self.dest) 1645 1646 def __str__(self): 1647 dest = self.dest and [">>%s" % self.dest] or [] 1648 return "print %s" % ", ".join(map(str, dest + self.nodes)) 1649 1650 def visit(self, visitor, *args): 1651 return visitor.visitPrintnl(self, *args) 1652 1653 class Raise(Node): 1654 def __init__(self, expr1, expr2, expr3, lineno=None): 1655 Node.__init__(self) 1656 self.expr1 = expr1 1657 self.expr2 = expr2 1658 self.expr3 = expr3 1659 self.lineno = lineno 1660 1661 def getChildren(self): 1662 children = [] 1663 children.append(self.expr1) 1664 children.append(self.expr2) 1665 children.append(self.expr3) 1666 return tuple(children) 1667 1668 def getChildNodes(self): 1669 nodelist = [] 1670 if self.expr1 is not None: 1671 nodelist.append(self.expr1) 1672 if self.expr2 is not None: 1673 nodelist.append(self.expr2) 1674 if self.expr3 is not None: 1675 nodelist.append(self.expr3) 1676 return tuple(nodelist) 1677 1678 def __repr__(self): 1679 return "Raise(%r, %r, %r)" % (self.expr1, self.expr2, self.expr3) 1680 1681 def __str__(self): 1682 args = self.expr1 and [self.expr1] or [] 1683 args += self.expr2 and [self.expr2] or [] 1684 args += self.expr3 and [self.expr3] or [] 1685 return "raise %s" % ", ".join(map(str, args)) 1686 1687 def visit(self, visitor, *args): 1688 return visitor.visitRaise(self, *args) 1689 1690 class Return(Node): 1691 def __init__(self, value, lineno=None): 1692 Node.__init__(self) 1693 self.value = value 1694 self.lineno = lineno 1695 1696 def getChildren(self): 1697 return self.value, 1698 1699 def getChildNodes(self): 1700 return self.value, 1701 1702 def __repr__(self): 1703 return "Return(%r)" % (self.value,) 1704 1705 def __str__(self): 1706 return "return %s" % self.value 1707 1708 def visit(self, visitor, *args): 1709 return visitor.visitReturn(self, *args) 1710 1711 class RightShift(Node, OperatorUser): 1712 def __init__(self, leftright, lineno=None): 1713 Node.__init__(self) 1714 OperatorUser.__init__(self) 1715 self.left = leftright[0] 1716 self.right = leftright[1] 1717 self.lineno = lineno 1718 1719 def getChildren(self): 1720 return self.left, self.right 1721 1722 def getChildNodes(self): 1723 return self.left, self.right 1724 1725 def __repr__(self): 1726 return "RightShift((%r, %r))" % (self.left, self.right) 1727 1728 def __str__(self): 1729 return "(%s >> %s)" % (self.left, self.right) 1730 1731 def visit(self, visitor, *args): 1732 return visitor.visitRightShift(self, *args) 1733 1734 class Set(Node): 1735 def __init__(self, nodes, lineno=None): 1736 self.nodes = nodes 1737 self.lineno = lineno 1738 1739 def getChildren(self): 1740 return tuple(flatten(self.nodes)) 1741 1742 def getChildNodes(self): 1743 nodelist = [] 1744 nodelist.extend(flatten_nodes(self.nodes)) 1745 return tuple(nodelist) 1746 1747 def __repr__(self): 1748 return "Set(%r)" % (self.nodes,) 1749 1750 def __str__(self): 1751 return "{%s}" % ", ".join(map(str, self.nodes)) 1752 1753 def visit(self, visitor, *args): 1754 return visitor.visitSet(self, *args) 1755 1756 class Slice(Node, OperatorUser): 1757 def __init__(self, expr, flags, lower, upper, lineno=None): 1758 Node.__init__(self) 1759 OperatorUser.__init__(self) 1760 self.expr = expr 1761 self.flags = flags 1762 self.lower = lower 1763 self.upper = upper 1764 self.lineno = lineno 1765 1766 def getChildren(self): 1767 children = [] 1768 children.append(self.expr) 1769 children.append(self.flags) 1770 children.append(self.lower) 1771 children.append(self.upper) 1772 return tuple(children) 1773 1774 def getChildNodes(self): 1775 nodelist = [] 1776 nodelist.append(self.expr) 1777 if self.lower is not None: 1778 nodelist.append(self.lower) 1779 if self.upper is not None: 1780 nodelist.append(self.upper) 1781 return tuple(nodelist) 1782 1783 def __repr__(self): 1784 return "Slice(%r, %r, %r, %r)" % (self.expr, self.flags, self.lower, self.upper) 1785 1786 def __str__(self): 1787 args = [] 1788 args = self.lower is not None and [self.lower] or [] 1789 args = self.upper is not None and [self.upper] or [] 1790 return "%s[%s]" % (self.expr, ":".join(map(str, args))) 1791 1792 def visit(self, visitor, *args): 1793 return visitor.visitSlice(self, *args) 1794 1795 class Sliceobj(Node): 1796 def __init__(self, nodes, lineno=None): 1797 Node.__init__(self) 1798 self.nodes = nodes 1799 self.lineno = lineno 1800 1801 def getChildren(self): 1802 return tuple(flatten(self.nodes)) 1803 1804 def getChildNodes(self): 1805 nodelist = [] 1806 nodelist.extend(flatten_nodes(self.nodes)) 1807 return tuple(nodelist) 1808 1809 def __repr__(self): 1810 return "Sliceobj(%r)" % (self.nodes,) 1811 1812 def __str__(self): 1813 return ":".join(map(str, self.nodes)) 1814 1815 def visit(self, visitor, *args): 1816 return visitor.visitSliceobj(self, *args) 1817 1818 class Stmt(Node): 1819 def __init__(self, nodes, lineno=None): 1820 Node.__init__(self) 1821 self.nodes = nodes 1822 self.lineno = lineno 1823 1824 def getChildren(self): 1825 return tuple(flatten(self.nodes)) 1826 1827 def getChildNodes(self): 1828 nodelist = [] 1829 nodelist.extend(flatten_nodes(self.nodes)) 1830 return tuple(nodelist) 1831 1832 def __repr__(self): 1833 return "Stmt(%r)" % (self.nodes,) 1834 1835 def __str__(self): 1836 return "\n".join(map(str, self.nodes)) 1837 1838 def visit(self, visitor, *args): 1839 return visitor.visitStmt(self, *args) 1840 1841 class Sub(Node, OperatorUser): 1842 def __init__(self, leftright, lineno=None): 1843 Node.__init__(self) 1844 OperatorUser.__init__(self) 1845 self.left = leftright[0] 1846 self.right = leftright[1] 1847 self.lineno = lineno 1848 1849 def getChildren(self): 1850 return self.left, self.right 1851 1852 def getChildNodes(self): 1853 return self.left, self.right 1854 1855 def __repr__(self): 1856 return "Sub((%r, %r))" % (self.left, self.right) 1857 1858 def __str__(self): 1859 return "(%s - %s)" % (self.left, self.right) 1860 1861 def visit(self, visitor, *args): 1862 return visitor.visitSub(self, *args) 1863 1864 class Subscript(Node, OperatorUser): 1865 def __init__(self, expr, flags, subs, lineno=None): 1866 Node.__init__(self) 1867 OperatorUser.__init__(self) 1868 self.expr = expr 1869 self.flags = flags 1870 self.subs = subs 1871 self.lineno = lineno 1872 1873 # Additional annotations. 1874 1875 self._expr = None 1876 self._attr = None 1877 self._attrusers = None 1878 self._username = None 1879 1880 def getChildren(self): 1881 children = [] 1882 children.append(self.expr) 1883 children.append(self.flags) 1884 children.extend(flatten(self.subs)) 1885 return tuple(children) 1886 1887 def getChildNodes(self): 1888 nodelist = [] 1889 nodelist.append(self.expr) 1890 nodelist.extend(flatten_nodes(self.subs)) 1891 return tuple(nodelist) 1892 1893 def __repr__(self): 1894 return "Subscript(%r, %r, %r)" % (self.expr, self.flags, self.subs) 1895 1896 def __str__(self): 1897 return "%s[%s]" % (self.expr, ",".join(map(str, self.subs))) 1898 1899 def visit(self, visitor, *args): 1900 return visitor.visitSubscript(self, *args) 1901 1902 class TryExcept(Node): 1903 def __init__(self, body, handlers, else_, lineno=None): 1904 Node.__init__(self) 1905 self.body = body 1906 self.handlers = handlers 1907 self.else_ = else_ 1908 self.lineno = lineno 1909 1910 def getChildren(self): 1911 children = [] 1912 children.append(self.body) 1913 children.extend(flatten(self.handlers)) 1914 children.append(self.else_) 1915 return tuple(children) 1916 1917 def getChildNodes(self): 1918 nodelist = [] 1919 nodelist.append(self.body) 1920 nodelist.extend(flatten_nodes(self.handlers)) 1921 if self.else_ is not None: 1922 nodelist.append(self.else_) 1923 return tuple(nodelist) 1924 1925 def __repr__(self): 1926 return "TryExcept(%r, %r, %r)" % (self.body, self.handlers, self.else_) 1927 1928 def __str__(self): 1929 handlers = [ 1930 ("\nexcept%s%s:%s" % (spec and " %s" % spec or "", assign and ", %s" % assign or "", indent("\n%s" % statement))) 1931 for (spec, assign, statement) in self.handlers 1932 ] 1933 1934 return "try:%s%s%s" % ( 1935 indent("\n%s" % self.body), 1936 "".join(handlers), 1937 self.else_ and "\nelse:%s" % indent("\n%s" % self.else_) or "" 1938 ) 1939 1940 def visit(self, visitor, *args): 1941 return visitor.visitTryExcept(self, *args) 1942 1943 class TryFinally(Node): 1944 def __init__(self, body, final, lineno=None): 1945 Node.__init__(self) 1946 self.body = body 1947 self.final = final 1948 self.lineno = lineno 1949 1950 def getChildren(self): 1951 return self.body, self.final 1952 1953 def getChildNodes(self): 1954 return self.body, self.final 1955 1956 def __repr__(self): 1957 return "TryFinally(%r, %r)" % (self.body, self.final) 1958 1959 def __str__(self): 1960 return "try:%s\nfinally:%s" % ( 1961 indent("\n%s" % self.body), 1962 indent("\n%s" % self.final) 1963 ) 1964 1965 def visit(self, visitor, *args): 1966 return visitor.visitTryFinally(self, *args) 1967 1968 class Tuple(Node): 1969 def __init__(self, nodes, lineno=None): 1970 Node.__init__(self) 1971 self.nodes = nodes 1972 self.lineno = lineno 1973 1974 def getChildren(self): 1975 return tuple(flatten(self.nodes)) 1976 1977 def getChildNodes(self): 1978 nodelist = [] 1979 nodelist.extend(flatten_nodes(self.nodes)) 1980 return tuple(nodelist) 1981 1982 def __repr__(self): 1983 return "Tuple(%r)" % (self.nodes,) 1984 1985 def __str__(self): 1986 return "(%s)" % ", ".join(map(str, self.nodes)) 1987 1988 def visit(self, visitor, *args): 1989 return visitor.visitTuple(self, *args) 1990 1991 class UnaryAdd(Node, OperatorUser): 1992 def __init__(self, expr, lineno=None): 1993 Node.__init__(self) 1994 OperatorUser.__init__(self) 1995 self.expr = expr 1996 self.lineno = lineno 1997 1998 def getChildren(self): 1999 return self.expr, 2000 2001 def getChildNodes(self): 2002 return self.expr, 2003 2004 def __repr__(self): 2005 return "UnaryAdd(%r)" % (self.expr,) 2006 2007 def __str__(self): 2008 return "+%s" % self.expr 2009 2010 def visit(self, visitor, *args): 2011 return visitor.visitUnaryAdd(self, *args) 2012 2013 class UnarySub(Node, OperatorUser): 2014 def __init__(self, expr, lineno=None): 2015 Node.__init__(self) 2016 OperatorUser.__init__(self) 2017 self.expr = expr 2018 self.lineno = lineno 2019 2020 def getChildren(self): 2021 return self.expr, 2022 2023 def getChildNodes(self): 2024 return self.expr, 2025 2026 def __repr__(self): 2027 return "UnarySub(%r)" % (self.expr,) 2028 2029 def __str__(self): 2030 return "-%s" % self.expr 2031 2032 def visit(self, visitor, *args): 2033 return visitor.visitUnarySub(self, *args) 2034 2035 class While(Node): 2036 def __init__(self, test, body, else_, lineno=None): 2037 Node.__init__(self) 2038 self.test = test 2039 self.body = body 2040 self.else_ = else_ 2041 self.lineno = lineno 2042 2043 def getChildren(self): 2044 children = [] 2045 children.append(self.test) 2046 children.append(self.body) 2047 children.append(self.else_) 2048 return tuple(children) 2049 2050 def getChildNodes(self): 2051 nodelist = [] 2052 nodelist.append(self.test) 2053 nodelist.append(self.body) 2054 if self.else_ is not None: 2055 nodelist.append(self.else_) 2056 return tuple(nodelist) 2057 2058 def __repr__(self): 2059 return "While(%r, %r, %r)" % (self.test, self.body, self.else_) 2060 2061 def __str__(self): 2062 return "while %s:%s%s" % ( 2063 self.test, 2064 indent("\n%s" % self.body), 2065 self.else_ and "\nelse:%s" % indent("\n%s" % self.else_) or "" 2066 ) 2067 2068 def visit(self, visitor, *args): 2069 return visitor.visitWhile(self, *args) 2070 2071 class With(Node): 2072 def __init__(self, expr, vars, body, lineno=None): 2073 Node.__init__(self) 2074 self.expr = expr 2075 self.vars = vars 2076 self.body = body 2077 self.lineno = lineno 2078 2079 def getChildren(self): 2080 children = [] 2081 children.append(self.expr) 2082 children.append(self.vars) 2083 children.append(self.body) 2084 return tuple(children) 2085 2086 def getChildNodes(self): 2087 nodelist = [] 2088 nodelist.append(self.expr) 2089 if self.vars is not None: 2090 nodelist.append(self.vars) 2091 nodelist.append(self.body) 2092 return tuple(nodelist) 2093 2094 def __repr__(self): 2095 return "With(%r, %r, %r)" % (self.expr, self.vars, self.body) 2096 2097 def __str__(self): 2098 return "with %s%s:%s" % ( 2099 self.expr, 2100 self.vars and " as %s" % ", ".join(map(str, self.vars)), 2101 indent("\n%s" % self.body), 2102 ) 2103 2104 def visit(self, visitor, *args): 2105 return visitor.visitWith(self, *args) 2106 2107 class Yield(Node): 2108 def __init__(self, value, lineno=None): 2109 Node.__init__(self) 2110 self.value = value 2111 self.lineno = lineno 2112 2113 def getChildren(self): 2114 return self.value, 2115 2116 def getChildNodes(self): 2117 return self.value, 2118 2119 def __repr__(self): 2120 return "Yield(%r)" % (self.value,) 2121 2122 def __str__(self): 2123 return "yield %s" % self.value 2124 2125 def visit(self, visitor, *args): 2126 return visitor.visitYield(self, *args) 2127 2128 for name, obj in globals().items(): 2129 if isinstance(obj, type) and issubclass(obj, Node): 2130 nodes[name.lower()] = obj