# HG changeset patch
# User Paul Boddie <paul@boddie.org.uk>
# Date 1335902913 -7200
# Node ID 322d424dacc148005328dd33f43d10ed13c7b1b4
# Parent  c4fd22e21d073499ea639caa4439269aac40e1c5
Added visit methods to the AST nodes for mutually-assisted dispatch to visitors.

diff -r c4fd22e21d07 -r 322d424dacc1 compiler/ast.py
--- a/compiler/ast.py	Tue May 01 22:04:53 2012 +0200
+++ b/compiler/ast.py	Tue May 01 22:08:33 2012 +0200
@@ -50,6 +50,9 @@
     def __repr__(self):
         return "Expression(%s)" % (repr(self.node))
 
+    def visit(self, visitor):
+        return visitor.visitExpression(self)
+
 class Add(Node):
     def __init__(self, (left, right), lineno=None):
         self.left = left
@@ -65,6 +68,9 @@
     def __repr__(self):
         return "Add((%s, %s))" % (repr(self.left), repr(self.right))
 
+    def visit(self, visitor):
+        return visitor.visitAdd(self)
+
 class And(Node):
     def __init__(self, nodes, lineno=None):
         self.nodes = nodes
@@ -81,6 +87,9 @@
     def __repr__(self):
         return "And(%s)" % (repr(self.nodes),)
 
+    def visit(self, visitor):
+        return visitor.visitAnd(self)
+
 class AssAttr(Node):
     def __init__(self, expr, attrname, flags, lineno=None):
         self.expr = expr
@@ -97,6 +106,9 @@
     def __repr__(self):
         return "AssAttr(%s, %s, %s)" % (repr(self.expr), repr(self.attrname), repr(self.flags))
 
+    def visit(self, visitor):
+        return visitor.visitAssAttr(self)
+
 class AssList(Node):
     def __init__(self, nodes, lineno=None):
         self.nodes = nodes
@@ -113,6 +125,9 @@
     def __repr__(self):
         return "AssList(%s)" % (repr(self.nodes),)
 
+    def visit(self, visitor):
+        return visitor.visitAssList(self)
+
 class AssName(Node):
     def __init__(self, name, flags, lineno=None):
         self.name = name
@@ -128,6 +143,9 @@
     def __repr__(self):
         return "AssName(%s, %s)" % (repr(self.name), repr(self.flags))
 
+    def visit(self, visitor):
+        return visitor.visitAssName(self)
+
 class AssTuple(Node):
     def __init__(self, nodes, lineno=None):
         self.nodes = nodes
@@ -144,6 +162,9 @@
     def __repr__(self):
         return "AssTuple(%s)" % (repr(self.nodes),)
 
+    def visit(self, visitor):
+        return visitor.visitAssTuple(self)
+
 class Assert(Node):
     def __init__(self, test, fail, lineno=None):
         self.test = test
@@ -166,6 +187,9 @@
     def __repr__(self):
         return "Assert(%s, %s)" % (repr(self.test), repr(self.fail))
 
+    def visit(self, visitor):
+        return visitor.visitAssert(self)
+
 class Assign(Node):
     def __init__(self, nodes, expr, lineno=None):
         self.nodes = nodes
@@ -187,6 +211,9 @@
     def __repr__(self):
         return "Assign(%s, %s)" % (repr(self.nodes), repr(self.expr))
 
+    def visit(self, visitor):
+        return visitor.visitAssign(self)
+
 class AugAssign(Node):
     def __init__(self, node, op, expr, lineno=None):
         self.node = node
@@ -203,6 +230,9 @@
     def __repr__(self):
         return "AugAssign(%s, %s, %s)" % (repr(self.node), repr(self.op), repr(self.expr))
 
+    def visit(self, visitor):
+        return visitor.visitAugAssign(self)
+
 class Backquote(Node):
     def __init__(self, expr, lineno=None):
         self.expr = expr
@@ -217,6 +247,9 @@
     def __repr__(self):
         return "Backquote(%s)" % (repr(self.expr),)
 
+    def visit(self, visitor):
+        return visitor.visitBackquote(self)
+
 class Bitand(Node):
     def __init__(self, nodes, lineno=None):
         self.nodes = nodes
@@ -233,6 +266,9 @@
     def __repr__(self):
         return "Bitand(%s)" % (repr(self.nodes),)
 
+    def visit(self, visitor):
+        return visitor.visitBitand(self)
+
 class Bitor(Node):
     def __init__(self, nodes, lineno=None):
         self.nodes = nodes
@@ -249,6 +285,9 @@
     def __repr__(self):
         return "Bitor(%s)" % (repr(self.nodes),)
 
+    def visit(self, visitor):
+        return visitor.visitBitor(self)
+
 class Bitxor(Node):
     def __init__(self, nodes, lineno=None):
         self.nodes = nodes
@@ -265,6 +304,9 @@
     def __repr__(self):
         return "Bitxor(%s)" % (repr(self.nodes),)
 
+    def visit(self, visitor):
+        return visitor.visitBitxor(self)
+
 class Break(Node):
     def __init__(self, lineno=None):
         self.lineno = lineno
@@ -278,6 +320,9 @@
     def __repr__(self):
         return "Break()"
 
+    def visit(self, visitor):
+        return visitor.visitBreak(self)
+
 class CallFunc(Node):
     def __init__(self, node, args, star_args = None, dstar_args = None, lineno=None):
         self.node = node
@@ -307,6 +352,9 @@
     def __repr__(self):
         return "CallFunc(%s, %s, %s, %s)" % (repr(self.node), repr(self.args), repr(self.star_args), repr(self.dstar_args))
 
+    def visit(self, visitor):
+        return visitor.visitCallFunc(self)
+
 class Class(Node):
     def __init__(self, name, bases, doc, code, lineno=None):
         self.name = name
@@ -332,6 +380,9 @@
     def __repr__(self):
         return "Class(%s, %s, %s, %s)" % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code))
 
+    def visit(self, visitor):
+        return visitor.visitClass(self)
+
 class Compare(Node):
     def __init__(self, expr, ops, lineno=None):
         self.expr = expr
@@ -353,6 +404,9 @@
     def __repr__(self):
         return "Compare(%s, %s)" % (repr(self.expr), repr(self.ops))
 
+    def visit(self, visitor):
+        return visitor.visitCompare(self)
+
 class Const(Node):
     def __init__(self, value, lineno=None):
         self.value = value
@@ -367,6 +421,9 @@
     def __repr__(self):
         return "Const(%s)" % (repr(self.value),)
 
+    def visit(self, visitor):
+        return visitor.visitConst(self)
+
 class Continue(Node):
     def __init__(self, lineno=None):
         self.lineno = lineno
@@ -380,6 +437,9 @@
     def __repr__(self):
         return "Continue()"
 
+    def visit(self, visitor):
+        return visitor.visitContinue(self)
+
 class Decorators(Node):
     def __init__(self, nodes, lineno=None):
         self.nodes = nodes
@@ -396,6 +456,9 @@
     def __repr__(self):
         return "Decorators(%s)" % (repr(self.nodes),)
 
+    def visit(self, visitor):
+        return visitor.visitDecorators(self)
+
 class Dict(Node):
     def __init__(self, items, lineno=None):
         self.items = items
@@ -412,6 +475,9 @@
     def __repr__(self):
         return "Dict(%s)" % (repr(self.items),)
 
+    def visit(self, visitor):
+        return visitor.visitDict(self)
+
 class Discard(Node):
     def __init__(self, expr, lineno=None):
         self.expr = expr
@@ -426,6 +492,9 @@
     def __repr__(self):
         return "Discard(%s)" % (repr(self.expr),)
 
+    def visit(self, visitor):
+        return visitor.visitDiscard(self)
+
 class Div(Node):
     def __init__(self, (left, right), lineno=None):
         self.left = left
@@ -441,6 +510,9 @@
     def __repr__(self):
         return "Div((%s, %s))" % (repr(self.left), repr(self.right))
 
+    def visit(self, visitor):
+        return visitor.visitDiv(self)
+
 class Ellipsis(Node):
     def __init__(self, lineno=None):
         self.lineno = lineno
@@ -454,6 +526,9 @@
     def __repr__(self):
         return "Ellipsis()"
 
+    def visit(self, visitor):
+        return visitor.visitEllipsis(self)
+
 class Exec(Node):
     def __init__(self, expr, locals, globals, lineno=None):
         self.expr = expr
@@ -480,6 +555,9 @@
     def __repr__(self):
         return "Exec(%s, %s, %s)" % (repr(self.expr), repr(self.locals), repr(self.globals))
 
+    def visit(self, visitor):
+        return visitor.visitExec(self)
+
 class FloorDiv(Node):
     def __init__(self, (left, right), lineno=None):
         self.left = left
@@ -495,6 +573,9 @@
     def __repr__(self):
         return "FloorDiv((%s, %s))" % (repr(self.left), repr(self.right))
 
+    def visit(self, visitor):
+        return visitor.visitFloorDiv(self)
+
 class For(Node):
     def __init__(self, assign, list, body, else_, lineno=None):
         self.assign = assign
@@ -523,6 +604,9 @@
     def __repr__(self):
         return "For(%s, %s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.body), repr(self.else_))
 
+    def visit(self, visitor):
+        return visitor.visitFor(self)
+
 class From(Node):
     def __init__(self, modname, names, level, lineno=None):
         self.modname = modname
@@ -539,6 +623,9 @@
     def __repr__(self):
         return "From(%s, %s, %s)" % (repr(self.modname), repr(self.names), repr(self.level))
 
+    def visit(self, visitor):
+        return visitor.visitFrom(self)
+
 class Function(Node):
     def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno=None):
         self.decorators = decorators
@@ -579,6 +666,9 @@
     def __repr__(self):
         return "Function(%s, %s, %s, %s, %s, %s, %s)" % (repr(self.decorators), repr(self.name), repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.doc), repr(self.code))
 
+    def visit(self, visitor):
+        return visitor.visitFunction(self)
+
 class GenExpr(Node):
     def __init__(self, code, lineno=None):
         self.code = code
@@ -595,6 +685,9 @@
     def __repr__(self):
         return "GenExpr(%s)" % (repr(self.code),)
 
+    def visit(self, visitor):
+        return visitor.visitGenExpr(self)
+
 class GenExprFor(Node):
     def __init__(self, assign, iter, ifs, lineno=None):
         self.assign = assign
@@ -621,6 +714,9 @@
     def __repr__(self):
         return "GenExprFor(%s, %s, %s)" % (repr(self.assign), repr(self.iter), repr(self.ifs))
 
+    def visit(self, visitor):
+        return visitor.visitGenExprFor(self)
+
 class GenExprIf(Node):
     def __init__(self, test, lineno=None):
         self.test = test
@@ -635,6 +731,9 @@
     def __repr__(self):
         return "GenExprIf(%s)" % (repr(self.test),)
 
+    def visit(self, visitor):
+        return visitor.visitGenExprIf(self)
+
 class GenExprInner(Node):
     def __init__(self, expr, quals, lineno=None):
         self.expr = expr
@@ -656,6 +755,9 @@
     def __repr__(self):
         return "GenExprInner(%s, %s)" % (repr(self.expr), repr(self.quals))
 
+    def visit(self, visitor):
+        return visitor.visitGenExprInner(self)
+
 class Getattr(Node):
     def __init__(self, expr, attrname, lineno=None):
         self.expr = expr
@@ -671,6 +773,9 @@
     def __repr__(self):
         return "Getattr(%s, %s)" % (repr(self.expr), repr(self.attrname))
 
+    def visit(self, visitor):
+        return visitor.visitGetattr(self)
+
 class Global(Node):
     def __init__(self, names, lineno=None):
         self.names = names
@@ -685,6 +790,9 @@
     def __repr__(self):
         return "Global(%s)" % (repr(self.names),)
 
+    def visit(self, visitor):
+        return visitor.visitGlobal(self)
+
 class If(Node):
     def __init__(self, tests, else_, lineno=None):
         self.tests = tests
@@ -707,6 +815,9 @@
     def __repr__(self):
         return "If(%s, %s)" % (repr(self.tests), repr(self.else_))
 
+    def visit(self, visitor):
+        return visitor.visitIf(self)
+
 class IfExp(Node):
     def __init__(self, test, then, else_, lineno=None):
         self.test = test
@@ -723,6 +834,9 @@
     def __repr__(self):
         return "IfExp(%s, %s, %s)" % (repr(self.test), repr(self.then), repr(self.else_))
 
+    def visit(self, visitor):
+        return visitor.visitIfExp(self)
+
 class Import(Node):
     def __init__(self, names, lineno=None):
         self.names = names
@@ -737,6 +851,9 @@
     def __repr__(self):
         return "Import(%s)" % (repr(self.names),)
 
+    def visit(self, visitor):
+        return visitor.visitImport(self)
+
 class Invert(Node):
     def __init__(self, expr, lineno=None):
         self.expr = expr
@@ -751,6 +868,9 @@
     def __repr__(self):
         return "Invert(%s)" % (repr(self.expr),)
 
+    def visit(self, visitor):
+        return visitor.visitInvert(self)
+
 class Keyword(Node):
     def __init__(self, name, expr, lineno=None):
         self.name = name
@@ -766,6 +886,9 @@
     def __repr__(self):
         return "Keyword(%s, %s)" % (repr(self.name), repr(self.expr))
 
+    def visit(self, visitor):
+        return visitor.visitKeyword(self)
+
 class Lambda(Node):
     def __init__(self, argnames, defaults, flags, code, lineno=None):
         self.argnames = argnames
@@ -798,6 +921,9 @@
     def __repr__(self):
         return "Lambda(%s, %s, %s, %s)" % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code))
 
+    def visit(self, visitor):
+        return visitor.visitLambda(self)
+
 class LeftShift(Node):
     def __init__(self, (left, right), lineno=None):
         self.left = left
@@ -813,6 +939,9 @@
     def __repr__(self):
         return "LeftShift((%s, %s))" % (repr(self.left), repr(self.right))
 
+    def visit(self, visitor):
+        return visitor.visitLeftShift(self)
+
 class List(Node):
     def __init__(self, nodes, lineno=None):
         self.nodes = nodes
@@ -829,6 +958,9 @@
     def __repr__(self):
         return "List(%s)" % (repr(self.nodes),)
 
+    def visit(self, visitor):
+        return visitor.visitList(self)
+
 class ListComp(Node):
     def __init__(self, expr, quals, lineno=None):
         self.expr = expr
@@ -850,6 +982,9 @@
     def __repr__(self):
         return "ListComp(%s, %s)" % (repr(self.expr), repr(self.quals))
 
+    def visit(self, visitor):
+        return visitor.visitListComp(self)
+
 class ListCompFor(Node):
     def __init__(self, assign, list, ifs, lineno=None):
         self.assign = assign
@@ -874,6 +1009,9 @@
     def __repr__(self):
         return "ListCompFor(%s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.ifs))
 
+    def visit(self, visitor):
+        return visitor.visitListCompFor(self)
+
 class ListCompIf(Node):
     def __init__(self, test, lineno=None):
         self.test = test
@@ -888,6 +1026,9 @@
     def __repr__(self):
         return "ListCompIf(%s)" % (repr(self.test),)
 
+    def visit(self, visitor):
+        return visitor.visitListCompIf(self)
+
 class Mod(Node):
     def __init__(self, (left, right), lineno=None):
         self.left = left
@@ -903,6 +1044,9 @@
     def __repr__(self):
         return "Mod((%s, %s))" % (repr(self.left), repr(self.right))
 
+    def visit(self, visitor):
+        return visitor.visitMod(self)
+
 class Module(Node):
     def __init__(self, doc, node, lineno=None):
         self.doc = doc
@@ -918,6 +1062,9 @@
     def __repr__(self):
         return "Module(%s, %s)" % (repr(self.doc), repr(self.node))
 
+    def visit(self, visitor):
+        return visitor.visitModule(self)
+
 class Mul(Node):
     def __init__(self, (left, right), lineno=None):
         self.left = left
@@ -933,6 +1080,9 @@
     def __repr__(self):
         return "Mul((%s, %s))" % (repr(self.left), repr(self.right))
 
+    def visit(self, visitor):
+        return visitor.visitMul(self)
+
 class Name(Node):
     def __init__(self, name, lineno=None):
         self.name = name
@@ -947,6 +1097,9 @@
     def __repr__(self):
         return "Name(%s)" % (repr(self.name),)
 
+    def visit(self, visitor):
+        return visitor.visitName(self)
+
 class Not(Node):
     def __init__(self, expr, lineno=None):
         self.expr = expr
@@ -961,6 +1114,9 @@
     def __repr__(self):
         return "Not(%s)" % (repr(self.expr),)
 
+    def visit(self, visitor):
+        return visitor.visitNot(self)
+
 class Or(Node):
     def __init__(self, nodes, lineno=None):
         self.nodes = nodes
@@ -977,6 +1133,9 @@
     def __repr__(self):
         return "Or(%s)" % (repr(self.nodes),)
 
+    def visit(self, visitor):
+        return visitor.visitOr(self)
+
 class Pass(Node):
     def __init__(self, lineno=None):
         self.lineno = lineno
@@ -990,6 +1149,9 @@
     def __repr__(self):
         return "Pass()"
 
+    def visit(self, visitor):
+        return visitor.visitPass(self)
+
 class Power(Node):
     def __init__(self, (left, right), lineno=None):
         self.left = left
@@ -1005,6 +1167,9 @@
     def __repr__(self):
         return "Power((%s, %s))" % (repr(self.left), repr(self.right))
 
+    def visit(self, visitor):
+        return visitor.visitPower(self)
+
 class Print(Node):
     def __init__(self, nodes, dest, lineno=None):
         self.nodes = nodes
@@ -1027,6 +1192,9 @@
     def __repr__(self):
         return "Print(%s, %s)" % (repr(self.nodes), repr(self.dest))
 
+    def visit(self, visitor):
+        return visitor.visitPrint(self)
+
 class Printnl(Node):
     def __init__(self, nodes, dest, lineno=None):
         self.nodes = nodes
@@ -1049,6 +1217,9 @@
     def __repr__(self):
         return "Printnl(%s, %s)" % (repr(self.nodes), repr(self.dest))
 
+    def visit(self, visitor):
+        return visitor.visitPrintnl(self)
+
 class Raise(Node):
     def __init__(self, expr1, expr2, expr3, lineno=None):
         self.expr1 = expr1
@@ -1076,6 +1247,9 @@
     def __repr__(self):
         return "Raise(%s, %s, %s)" % (repr(self.expr1), repr(self.expr2), repr(self.expr3))
 
+    def visit(self, visitor):
+        return visitor.visitRaise(self)
+
 class Return(Node):
     def __init__(self, value, lineno=None):
         self.value = value
@@ -1090,6 +1264,9 @@
     def __repr__(self):
         return "Return(%s)" % (repr(self.value),)
 
+    def visit(self, visitor):
+        return visitor.visitReturn(self)
+
 class RightShift(Node):
     def __init__(self, (left, right), lineno=None):
         self.left = left
@@ -1105,6 +1282,9 @@
     def __repr__(self):
         return "RightShift((%s, %s))" % (repr(self.left), repr(self.right))
 
+    def visit(self, visitor):
+        return visitor.visitRightShift(self)
+
 class Slice(Node):
     def __init__(self, expr, flags, lower, upper, lineno=None):
         self.expr = expr
@@ -1133,6 +1313,9 @@
     def __repr__(self):
         return "Slice(%s, %s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.upper))
 
+    def visit(self, visitor):
+        return visitor.visitSlice(self)
+
 class Sliceobj(Node):
     def __init__(self, nodes, lineno=None):
         self.nodes = nodes
@@ -1149,6 +1332,9 @@
     def __repr__(self):
         return "Sliceobj(%s)" % (repr(self.nodes),)
 
+    def visit(self, visitor):
+        return visitor.visitSliceobj(self)
+
 class Stmt(Node):
     def __init__(self, nodes, lineno=None):
         self.nodes = nodes
@@ -1165,6 +1351,9 @@
     def __repr__(self):
         return "Stmt(%s)" % (repr(self.nodes),)
 
+    def visit(self, visitor):
+        return visitor.visitStmt(self)
+
 class Sub(Node):
     def __init__(self, (left, right), lineno=None):
         self.left = left
@@ -1180,6 +1369,9 @@
     def __repr__(self):
         return "Sub((%s, %s))" % (repr(self.left), repr(self.right))
 
+    def visit(self, visitor):
+        return visitor.visitSub(self)
+
 class Subscript(Node):
     def __init__(self, expr, flags, subs, lineno=None):
         self.expr = expr
@@ -1203,6 +1395,9 @@
     def __repr__(self):
         return "Subscript(%s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.subs))
 
+    def visit(self, visitor):
+        return visitor.visitSubscript(self)
+
 class TryExcept(Node):
     def __init__(self, body, handlers, else_, lineno=None):
         self.body = body
@@ -1228,6 +1423,9 @@
     def __repr__(self):
         return "TryExcept(%s, %s, %s)" % (repr(self.body), repr(self.handlers), repr(self.else_))
 
+    def visit(self, visitor):
+        return visitor.visitTryExcept(self)
+
 class TryFinally(Node):
     def __init__(self, body, final, lineno=None):
         self.body = body
@@ -1243,6 +1441,9 @@
     def __repr__(self):
         return "TryFinally(%s, %s)" % (repr(self.body), repr(self.final))
 
+    def visit(self, visitor):
+        return visitor.visitTryFinally(self)
+
 class Tuple(Node):
     def __init__(self, nodes, lineno=None):
         self.nodes = nodes
@@ -1259,6 +1460,9 @@
     def __repr__(self):
         return "Tuple(%s)" % (repr(self.nodes),)
 
+    def visit(self, visitor):
+        return visitor.visitTuple(self)
+
 class UnaryAdd(Node):
     def __init__(self, expr, lineno=None):
         self.expr = expr
@@ -1273,6 +1477,9 @@
     def __repr__(self):
         return "UnaryAdd(%s)" % (repr(self.expr),)
 
+    def visit(self, visitor):
+        return visitor.visitUnaryAdd(self)
+
 class UnarySub(Node):
     def __init__(self, expr, lineno=None):
         self.expr = expr
@@ -1287,6 +1494,9 @@
     def __repr__(self):
         return "UnarySub(%s)" % (repr(self.expr),)
 
+    def visit(self, visitor):
+        return visitor.visitUnarySub(self)
+
 class While(Node):
     def __init__(self, test, body, else_, lineno=None):
         self.test = test
@@ -1312,6 +1522,9 @@
     def __repr__(self):
         return "While(%s, %s, %s)" % (repr(self.test), repr(self.body), repr(self.else_))
 
+    def visit(self, visitor):
+        return visitor.visitWhile(self)
+
 class With(Node):
     def __init__(self, expr, vars, body, lineno=None):
         self.expr = expr
@@ -1337,6 +1550,9 @@
     def __repr__(self):
         return "With(%s, %s, %s)" % (repr(self.expr), repr(self.vars), repr(self.body))
 
+    def visit(self, visitor):
+        return visitor.visitWith(self)
+
 class Yield(Node):
     def __init__(self, value, lineno=None):
         self.value = value
@@ -1351,6 +1567,9 @@
     def __repr__(self):
         return "Yield(%s)" % (repr(self.value),)
 
+    def visit(self, visitor):
+        return visitor.visitYield(self)
+
 for name, obj in globals().items():
     if isinstance(obj, type) and issubclass(obj, Node):
         nodes[name.lower()] = obj