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