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