[pypy-commit] pypy split-ast-classes: Remove all Python-level code from the ast classes,

amauryfa noreply at buildbot.pypy.org
Wed Jun 26 23:22:03 CEST 2013


Author: Amaury Forgeot d'Arc <amauryfa at gmail.com>
Branch: split-ast-classes
Changeset: r65013:7356f3a68d37
Date: 2013-06-21 19:06 +0200
http://bitbucket.org/pypy/pypy/changeset/7356f3a68d37/

Log:	Remove all Python-level code from the ast classes, only keep the
	minimum for the compiler.

	The ast module is broken, of course, but the interpreter works.

diff too long, truncating to 2000 out of 6858 lines

diff --git a/pypy/interpreter/astcompiler/ast.py b/pypy/interpreter/astcompiler/ast.py
--- a/pypy/interpreter/astcompiler/ast.py
+++ b/pypy/interpreter/astcompiler/ast.py
@@ -1,25 +1,9 @@
 # Generated by tools/asdl_py.py
-from pypy.interpreter.baseobjspace import W_Root
-from pypy.interpreter import typedef
-from pypy.interpreter.gateway import interp2app
-from pypy.interpreter.error import OperationError, operationerrfmt
-from rpython.rlib.unroll import unrolling_iterable
+from pypy.interpreter.error import OperationError
 from rpython.tool.pairtype import extendabletype
-from rpython.tool.sourcetools import func_with_new_name
 
 
-def check_string(space, w_obj):
-    if not (space.isinstance_w(w_obj, space.w_str) or
-            space.isinstance_w(w_obj, space.w_unicode)):
-        raise OperationError(space.w_TypeError, space.wrap(
-                'AST string must be of type str or unicode'))
-    return w_obj
-
-
-class AST(W_Root):
-
-    w_dict = None
-
+class AST(object):
     __metaclass__ = extendabletype
 
     def walkabout(self, visitor):
@@ -28,100 +12,10 @@
     def mutate_over(self, visitor):
         raise AssertionError("mutate_over() implementation not provided")
 
-    def sync_app_attrs(self, space):
-        raise NotImplementedError
-
-    def getdict(self, space):
-        if self.w_dict is None:
-            self.w_dict = space.newdict(instance=True)
-        return self.w_dict
-
-    def reduce_w(self, space):
-        w_dict = self.w_dict
-        if w_dict is None:
-            w_dict = space.newdict()
-        w_type = space.type(self)
-        w_fields = w_type.getdictvalue(space, "_fields")
-        for w_name in space.fixedview(w_fields):
-            space.setitem(w_dict, w_name,
-                          space.getattr(self, w_name))
-        w_attrs = space.findattr(w_type, space.wrap("_attributes"))
-        if w_attrs:
-            for w_name in space.fixedview(w_attrs):
-                space.setitem(w_dict, w_name,
-                              space.getattr(self, w_name))
-        return space.newtuple([space.type(self),
-                               space.newtuple([]),
-                               w_dict])
-
-    def setstate_w(self, space, w_state):
-        for w_name in space.unpackiterable(w_state):
-            space.setattr(self, w_name,
-                          space.getitem(w_state, w_name))
-
-    def missing_field(self, space, required, host):
-        "Find which required field is missing."
-        state = self.initialization_state
-        for i in range(len(required)):
-            if (state >> i) & 1:
-                continue  # field is present
-            missing = required[i]
-            if missing is None:
-                continue  # field is optional
-            w_obj = self.getdictvalue(space, missing)
-            if w_obj is None:
-                err = "required field \"%s\" missing from %s"
-                raise operationerrfmt(space.w_TypeError, err, missing, host)
-            else:
-                err = "incorrect type for field \"%s\" in %s"
-                raise operationerrfmt(space.w_TypeError, err, missing, host)
-        raise AssertionError("should not reach here")
-
 
 class NodeVisitorNotImplemented(Exception):
     pass
 
-
-class _FieldsWrapper(W_Root):
-    "Hack around the fact we can't store tuples on a TypeDef."
-
-    def __init__(self, fields):
-        self.fields = fields
-
-    def __spacebind__(self, space):
-        return space.newtuple([space.wrap(field) for field in self.fields])
-
-
-def get_AST_new(node_class):
-    def generic_AST_new(space, w_type, __args__):
-        node = space.allocate_instance(node_class, w_type)
-        node.initialization_state = 0
-        return space.wrap(node)
-    return func_with_new_name(generic_AST_new, "new_%s" % node_class.__name__)
-
-def AST_init(space, w_self, __args__):
-    args_w, kwargs_w = __args__.unpack()
-    if args_w and len(args_w) != 0:
-        w_err = space.wrap("_ast.AST constructor takes 0 positional arguments")
-        raise OperationError(space.w_TypeError, w_err)
-    for field, w_value in kwargs_w.iteritems():
-        space.setattr(w_self, space.wrap(field), w_value)
-
-AST.typedef = typedef.TypeDef("AST",
-    _fields=_FieldsWrapper([]),
-    _attributes=_FieldsWrapper([]),
-    __module__='_ast',
-    __reduce__=interp2app(AST.reduce_w),
-    __setstate__=interp2app(AST.setstate_w),
-    __dict__ = typedef.GetSetProperty(typedef.descr_get_dict,
-                                      typedef.descr_set_dict, cls=AST),
-    __new__=interp2app(get_AST_new(AST)),
-    __init__=interp2app(AST_init),
-)
-
-
-
-
 class mod(AST):
     pass
 
@@ -129,8 +23,6 @@
 
     def __init__(self, body):
         self.body = body
-        self.w_body = None
-        self.initialization_state = 1
 
     def walkabout(self, visitor):
         visitor.visit_Module(self)
@@ -140,29 +32,11 @@
             visitor._mutate_sequence(self.body)
         return visitor.visit_Module(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 1:
-            self.missing_field(space, ['body'], 'Module')
-        else:
-            pass
-        w_list = self.w_body
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
-            else:
-                self.body = None
-        if self.body is not None:
-            for node in self.body:
-                node.sync_app_attrs(space)
-
 
 class Interactive(mod):
 
     def __init__(self, body):
         self.body = body
-        self.w_body = None
-        self.initialization_state = 1
 
     def walkabout(self, visitor):
         visitor.visit_Interactive(self)
@@ -172,28 +46,11 @@
             visitor._mutate_sequence(self.body)
         return visitor.visit_Interactive(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 1:
-            self.missing_field(space, ['body'], 'Interactive')
-        else:
-            pass
-        w_list = self.w_body
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
-            else:
-                self.body = None
-        if self.body is not None:
-            for node in self.body:
-                node.sync_app_attrs(space)
-
 
 class Expression(mod):
 
     def __init__(self, body):
         self.body = body
-        self.initialization_state = 1
 
     def walkabout(self, visitor):
         visitor.visit_Expression(self)
@@ -202,20 +59,11 @@
         self.body = self.body.mutate_over(visitor)
         return visitor.visit_Expression(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 1:
-            self.missing_field(space, ['body'], 'Expression')
-        else:
-            pass
-        self.body.sync_app_attrs(space)
-
 
 class Suite(mod):
 
     def __init__(self, body):
         self.body = body
-        self.w_body = None
-        self.initialization_state = 1
 
     def walkabout(self, visitor):
         visitor.visit_Suite(self)
@@ -225,22 +73,6 @@
             visitor._mutate_sequence(self.body)
         return visitor.visit_Suite(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 1:
-            self.missing_field(space, ['body'], 'Suite')
-        else:
-            pass
-        w_list = self.w_body
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
-            else:
-                self.body = None
-        if self.body is not None:
-            for node in self.body:
-                node.sync_app_attrs(space)
-
 
 class stmt(AST):
 
@@ -254,11 +86,8 @@
         self.name = name
         self.args = args
         self.body = body
-        self.w_body = None
         self.decorator_list = decorator_list
-        self.w_decorator_list = None
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 63
 
     def walkabout(self, visitor):
         visitor.visit_FunctionDef(self)
@@ -271,46 +100,15 @@
             visitor._mutate_sequence(self.decorator_list)
         return visitor.visit_FunctionDef(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 63:
-            self.missing_field(space, ['lineno', 'col_offset', 'name', 'args', 'body', 'decorator_list'], 'FunctionDef')
-        else:
-            pass
-        self.args.sync_app_attrs(space)
-        w_list = self.w_body
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
-            else:
-                self.body = None
-        if self.body is not None:
-            for node in self.body:
-                node.sync_app_attrs(space)
-        w_list = self.w_decorator_list
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.decorator_list = [space.interp_w(expr, w_obj) for w_obj in list_w]
-            else:
-                self.decorator_list = None
-        if self.decorator_list is not None:
-            for node in self.decorator_list:
-                node.sync_app_attrs(space)
-
 
 class ClassDef(stmt):
 
     def __init__(self, name, bases, body, decorator_list, lineno, col_offset):
         self.name = name
         self.bases = bases
-        self.w_bases = None
         self.body = body
-        self.w_body = None
         self.decorator_list = decorator_list
-        self.w_decorator_list = None
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 63
 
     def walkabout(self, visitor):
         visitor.visit_ClassDef(self)
@@ -324,49 +122,12 @@
             visitor._mutate_sequence(self.decorator_list)
         return visitor.visit_ClassDef(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 63:
-            self.missing_field(space, ['lineno', 'col_offset', 'name', 'bases', 'body', 'decorator_list'], 'ClassDef')
-        else:
-            pass
-        w_list = self.w_bases
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.bases = [space.interp_w(expr, w_obj) for w_obj in list_w]
-            else:
-                self.bases = None
-        if self.bases is not None:
-            for node in self.bases:
-                node.sync_app_attrs(space)
-        w_list = self.w_body
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
-            else:
-                self.body = None
-        if self.body is not None:
-            for node in self.body:
-                node.sync_app_attrs(space)
-        w_list = self.w_decorator_list
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.decorator_list = [space.interp_w(expr, w_obj) for w_obj in list_w]
-            else:
-                self.decorator_list = None
-        if self.decorator_list is not None:
-            for node in self.decorator_list:
-                node.sync_app_attrs(space)
-
 
 class Return(stmt):
 
     def __init__(self, value, lineno, col_offset):
         self.value = value
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 7
 
     def walkabout(self, visitor):
         visitor.visit_Return(self)
@@ -376,23 +137,12 @@
             self.value = self.value.mutate_over(visitor)
         return visitor.visit_Return(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~4) ^ 3:
-            self.missing_field(space, ['lineno', 'col_offset', None], 'Return')
-        else:
-            if not self.initialization_state & 4:
-                self.value = None
-        if self.value:
-            self.value.sync_app_attrs(space)
-
 
 class Delete(stmt):
 
     def __init__(self, targets, lineno, col_offset):
         self.targets = targets
-        self.w_targets = None
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 7
 
     def walkabout(self, visitor):
         visitor.visit_Delete(self)
@@ -402,31 +152,13 @@
             visitor._mutate_sequence(self.targets)
         return visitor.visit_Delete(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 7:
-            self.missing_field(space, ['lineno', 'col_offset', 'targets'], 'Delete')
-        else:
-            pass
-        w_list = self.w_targets
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.targets = [space.interp_w(expr, w_obj) for w_obj in list_w]
-            else:
-                self.targets = None
-        if self.targets is not None:
-            for node in self.targets:
-                node.sync_app_attrs(space)
-
 
 class Assign(stmt):
 
     def __init__(self, targets, value, lineno, col_offset):
         self.targets = targets
-        self.w_targets = None
         self.value = value
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 15
 
     def walkabout(self, visitor):
         visitor.visit_Assign(self)
@@ -437,23 +169,6 @@
         self.value = self.value.mutate_over(visitor)
         return visitor.visit_Assign(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 15:
-            self.missing_field(space, ['lineno', 'col_offset', 'targets', 'value'], 'Assign')
-        else:
-            pass
-        w_list = self.w_targets
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.targets = [space.interp_w(expr, w_obj) for w_obj in list_w]
-            else:
-                self.targets = None
-        if self.targets is not None:
-            for node in self.targets:
-                node.sync_app_attrs(space)
-        self.value.sync_app_attrs(space)
-
 
 class AugAssign(stmt):
 
@@ -462,7 +177,6 @@
         self.op = op
         self.value = value
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 31
 
     def walkabout(self, visitor):
         visitor.visit_AugAssign(self)
@@ -472,24 +186,14 @@
         self.value = self.value.mutate_over(visitor)
         return visitor.visit_AugAssign(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 31:
-            self.missing_field(space, ['lineno', 'col_offset', 'target', 'op', 'value'], 'AugAssign')
-        else:
-            pass
-        self.target.sync_app_attrs(space)
-        self.value.sync_app_attrs(space)
-
 
 class Print(stmt):
 
     def __init__(self, dest, values, nl, lineno, col_offset):
         self.dest = dest
         self.values = values
-        self.w_values = None
         self.nl = nl
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 31
 
     def walkabout(self, visitor):
         visitor.visit_Print(self)
@@ -501,25 +205,6 @@
             visitor._mutate_sequence(self.values)
         return visitor.visit_Print(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~4) ^ 27:
-            self.missing_field(space, ['lineno', 'col_offset', None, 'values', 'nl'], 'Print')
-        else:
-            if not self.initialization_state & 4:
-                self.dest = None
-        if self.dest:
-            self.dest.sync_app_attrs(space)
-        w_list = self.w_values
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.values = [space.interp_w(expr, w_obj) for w_obj in list_w]
-            else:
-                self.values = None
-        if self.values is not None:
-            for node in self.values:
-                node.sync_app_attrs(space)
-
 
 class For(stmt):
 
@@ -527,11 +212,8 @@
         self.target = target
         self.iter = iter
         self.body = body
-        self.w_body = None
         self.orelse = orelse
-        self.w_orelse = None
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 63
 
     def walkabout(self, visitor):
         visitor.visit_For(self)
@@ -545,45 +227,14 @@
             visitor._mutate_sequence(self.orelse)
         return visitor.visit_For(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 63:
-            self.missing_field(space, ['lineno', 'col_offset', 'target', 'iter', 'body', 'orelse'], 'For')
-        else:
-            pass
-        self.target.sync_app_attrs(space)
-        self.iter.sync_app_attrs(space)
-        w_list = self.w_body
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
-            else:
-                self.body = None
-        if self.body is not None:
-            for node in self.body:
-                node.sync_app_attrs(space)
-        w_list = self.w_orelse
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.orelse = [space.interp_w(stmt, w_obj) for w_obj in list_w]
-            else:
-                self.orelse = None
-        if self.orelse is not None:
-            for node in self.orelse:
-                node.sync_app_attrs(space)
-
 
 class While(stmt):
 
     def __init__(self, test, body, orelse, lineno, col_offset):
         self.test = test
         self.body = body
-        self.w_body = None
         self.orelse = orelse
-        self.w_orelse = None
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 31
 
     def walkabout(self, visitor):
         visitor.visit_While(self)
@@ -596,44 +247,14 @@
             visitor._mutate_sequence(self.orelse)
         return visitor.visit_While(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 31:
-            self.missing_field(space, ['lineno', 'col_offset', 'test', 'body', 'orelse'], 'While')
-        else:
-            pass
-        self.test.sync_app_attrs(space)
-        w_list = self.w_body
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
-            else:
-                self.body = None
-        if self.body is not None:
-            for node in self.body:
-                node.sync_app_attrs(space)
-        w_list = self.w_orelse
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.orelse = [space.interp_w(stmt, w_obj) for w_obj in list_w]
-            else:
-                self.orelse = None
-        if self.orelse is not None:
-            for node in self.orelse:
-                node.sync_app_attrs(space)
-
 
 class If(stmt):
 
     def __init__(self, test, body, orelse, lineno, col_offset):
         self.test = test
         self.body = body
-        self.w_body = None
         self.orelse = orelse
-        self.w_orelse = None
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 31
 
     def walkabout(self, visitor):
         visitor.visit_If(self)
@@ -646,33 +267,6 @@
             visitor._mutate_sequence(self.orelse)
         return visitor.visit_If(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 31:
-            self.missing_field(space, ['lineno', 'col_offset', 'test', 'body', 'orelse'], 'If')
-        else:
-            pass
-        self.test.sync_app_attrs(space)
-        w_list = self.w_body
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
-            else:
-                self.body = None
-        if self.body is not None:
-            for node in self.body:
-                node.sync_app_attrs(space)
-        w_list = self.w_orelse
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.orelse = [space.interp_w(stmt, w_obj) for w_obj in list_w]
-            else:
-                self.orelse = None
-        if self.orelse is not None:
-            for node in self.orelse:
-                node.sync_app_attrs(space)
-
 
 class With(stmt):
 
@@ -680,9 +274,7 @@
         self.context_expr = context_expr
         self.optional_vars = optional_vars
         self.body = body
-        self.w_body = None
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 31
 
     def walkabout(self, visitor):
         visitor.visit_With(self)
@@ -695,26 +287,6 @@
             visitor._mutate_sequence(self.body)
         return visitor.visit_With(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~8) ^ 23:
-            self.missing_field(space, ['lineno', 'col_offset', 'context_expr', None, 'body'], 'With')
-        else:
-            if not self.initialization_state & 8:
-                self.optional_vars = None
-        self.context_expr.sync_app_attrs(space)
-        if self.optional_vars:
-            self.optional_vars.sync_app_attrs(space)
-        w_list = self.w_body
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
-            else:
-                self.body = None
-        if self.body is not None:
-            for node in self.body:
-                node.sync_app_attrs(space)
-
 
 class Raise(stmt):
 
@@ -723,7 +295,6 @@
         self.inst = inst
         self.tback = tback
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 31
 
     def walkabout(self, visitor):
         visitor.visit_Raise(self)
@@ -737,35 +308,14 @@
             self.tback = self.tback.mutate_over(visitor)
         return visitor.visit_Raise(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~28) ^ 3:
-            self.missing_field(space, ['lineno', 'col_offset', None, None, None], 'Raise')
-        else:
-            if not self.initialization_state & 4:
-                self.type = None
-            if not self.initialization_state & 8:
-                self.inst = None
-            if not self.initialization_state & 16:
-                self.tback = None
-        if self.type:
-            self.type.sync_app_attrs(space)
-        if self.inst:
-            self.inst.sync_app_attrs(space)
-        if self.tback:
-            self.tback.sync_app_attrs(space)
-
 
 class TryExcept(stmt):
 
     def __init__(self, body, handlers, orelse, lineno, col_offset):
         self.body = body
-        self.w_body = None
         self.handlers = handlers
-        self.w_handlers = None
         self.orelse = orelse
-        self.w_orelse = None
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 31
 
     def walkabout(self, visitor):
         visitor.visit_TryExcept(self)
@@ -779,52 +329,13 @@
             visitor._mutate_sequence(self.orelse)
         return visitor.visit_TryExcept(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 31:
-            self.missing_field(space, ['lineno', 'col_offset', 'body', 'handlers', 'orelse'], 'TryExcept')
-        else:
-            pass
-        w_list = self.w_body
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
-            else:
-                self.body = None
-        if self.body is not None:
-            for node in self.body:
-                node.sync_app_attrs(space)
-        w_list = self.w_handlers
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.handlers = [space.interp_w(excepthandler, w_obj) for w_obj in list_w]
-            else:
-                self.handlers = None
-        if self.handlers is not None:
-            for node in self.handlers:
-                node.sync_app_attrs(space)
-        w_list = self.w_orelse
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.orelse = [space.interp_w(stmt, w_obj) for w_obj in list_w]
-            else:
-                self.orelse = None
-        if self.orelse is not None:
-            for node in self.orelse:
-                node.sync_app_attrs(space)
-
 
 class TryFinally(stmt):
 
     def __init__(self, body, finalbody, lineno, col_offset):
         self.body = body
-        self.w_body = None
         self.finalbody = finalbody
-        self.w_finalbody = None
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 15
 
     def walkabout(self, visitor):
         visitor.visit_TryFinally(self)
@@ -836,32 +347,6 @@
             visitor._mutate_sequence(self.finalbody)
         return visitor.visit_TryFinally(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 15:
-            self.missing_field(space, ['lineno', 'col_offset', 'body', 'finalbody'], 'TryFinally')
-        else:
-            pass
-        w_list = self.w_body
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
-            else:
-                self.body = None
-        if self.body is not None:
-            for node in self.body:
-                node.sync_app_attrs(space)
-        w_list = self.w_finalbody
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.finalbody = [space.interp_w(stmt, w_obj) for w_obj in list_w]
-            else:
-                self.finalbody = None
-        if self.finalbody is not None:
-            for node in self.finalbody:
-                node.sync_app_attrs(space)
-
 
 class Assert(stmt):
 
@@ -869,7 +354,6 @@
         self.test = test
         self.msg = msg
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 15
 
     def walkabout(self, visitor):
         visitor.visit_Assert(self)
@@ -880,24 +364,12 @@
             self.msg = self.msg.mutate_over(visitor)
         return visitor.visit_Assert(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~8) ^ 7:
-            self.missing_field(space, ['lineno', 'col_offset', 'test', None], 'Assert')
-        else:
-            if not self.initialization_state & 8:
-                self.msg = None
-        self.test.sync_app_attrs(space)
-        if self.msg:
-            self.msg.sync_app_attrs(space)
-
 
 class Import(stmt):
 
     def __init__(self, names, lineno, col_offset):
         self.names = names
-        self.w_names = None
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 7
 
     def walkabout(self, visitor):
         visitor.visit_Import(self)
@@ -907,32 +379,14 @@
             visitor._mutate_sequence(self.names)
         return visitor.visit_Import(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 7:
-            self.missing_field(space, ['lineno', 'col_offset', 'names'], 'Import')
-        else:
-            pass
-        w_list = self.w_names
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.names = [space.interp_w(alias, w_obj) for w_obj in list_w]
-            else:
-                self.names = None
-        if self.names is not None:
-            for node in self.names:
-                node.sync_app_attrs(space)
-
 
 class ImportFrom(stmt):
 
     def __init__(self, module, names, level, lineno, col_offset):
         self.module = module
         self.names = names
-        self.w_names = None
         self.level = level
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 31
 
     def walkabout(self, visitor):
         visitor.visit_ImportFrom(self)
@@ -942,25 +396,6 @@
             visitor._mutate_sequence(self.names)
         return visitor.visit_ImportFrom(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~20) ^ 11:
-            self.missing_field(space, ['lineno', 'col_offset', None, 'names', None], 'ImportFrom')
-        else:
-            if not self.initialization_state & 4:
-                self.module = None
-            if not self.initialization_state & 16:
-                self.level = 0
-        w_list = self.w_names
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.names = [space.interp_w(alias, w_obj) for w_obj in list_w]
-            else:
-                self.names = None
-        if self.names is not None:
-            for node in self.names:
-                node.sync_app_attrs(space)
-
 
 class Exec(stmt):
 
@@ -969,7 +404,6 @@
         self.globals = globals
         self.locals = locals
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 31
 
     def walkabout(self, visitor):
         visitor.visit_Exec(self)
@@ -982,28 +416,12 @@
             self.locals = self.locals.mutate_over(visitor)
         return visitor.visit_Exec(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~24) ^ 7:
-            self.missing_field(space, ['lineno', 'col_offset', 'body', None, None], 'Exec')
-        else:
-            if not self.initialization_state & 8:
-                self.globals = None
-            if not self.initialization_state & 16:
-                self.locals = None
-        self.body.sync_app_attrs(space)
-        if self.globals:
-            self.globals.sync_app_attrs(space)
-        if self.locals:
-            self.locals.sync_app_attrs(space)
-
 
 class Global(stmt):
 
     def __init__(self, names, lineno, col_offset):
         self.names = names
-        self.w_names = None
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 7
 
     def walkabout(self, visitor):
         visitor.visit_Global(self)
@@ -1011,26 +429,12 @@
     def mutate_over(self, visitor):
         return visitor.visit_Global(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 7:
-            self.missing_field(space, ['lineno', 'col_offset', 'names'], 'Global')
-        else:
-            pass
-        w_list = self.w_names
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.names = [space.realstr_w(w_obj) for w_obj in list_w]
-            else:
-                self.names = None
-
 
 class Expr(stmt):
 
     def __init__(self, value, lineno, col_offset):
         self.value = value
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 7
 
     def walkabout(self, visitor):
         visitor.visit_Expr(self)
@@ -1039,19 +443,11 @@
         self.value = self.value.mutate_over(visitor)
         return visitor.visit_Expr(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 7:
-            self.missing_field(space, ['lineno', 'col_offset', 'value'], 'Expr')
-        else:
-            pass
-        self.value.sync_app_attrs(space)
-
 
 class Pass(stmt):
 
     def __init__(self, lineno, col_offset):
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 3
 
     def walkabout(self, visitor):
         visitor.visit_Pass(self)
@@ -1059,18 +455,11 @@
     def mutate_over(self, visitor):
         return visitor.visit_Pass(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 3:
-            self.missing_field(space, ['lineno', 'col_offset'], 'Pass')
-        else:
-            pass
-
 
 class Break(stmt):
 
     def __init__(self, lineno, col_offset):
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 3
 
     def walkabout(self, visitor):
         visitor.visit_Break(self)
@@ -1078,18 +467,11 @@
     def mutate_over(self, visitor):
         return visitor.visit_Break(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 3:
-            self.missing_field(space, ['lineno', 'col_offset'], 'Break')
-        else:
-            pass
-
 
 class Continue(stmt):
 
     def __init__(self, lineno, col_offset):
         stmt.__init__(self, lineno, col_offset)
-        self.initialization_state = 3
 
     def walkabout(self, visitor):
         visitor.visit_Continue(self)
@@ -1097,12 +479,6 @@
     def mutate_over(self, visitor):
         return visitor.visit_Continue(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 3:
-            self.missing_field(space, ['lineno', 'col_offset'], 'Continue')
-        else:
-            pass
-
 
 class expr(AST):
 
@@ -1115,9 +491,7 @@
     def __init__(self, op, values, lineno, col_offset):
         self.op = op
         self.values = values
-        self.w_values = None
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 15
 
     def walkabout(self, visitor):
         visitor.visit_BoolOp(self)
@@ -1127,22 +501,6 @@
             visitor._mutate_sequence(self.values)
         return visitor.visit_BoolOp(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 15:
-            self.missing_field(space, ['lineno', 'col_offset', 'op', 'values'], 'BoolOp')
-        else:
-            pass
-        w_list = self.w_values
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.values = [space.interp_w(expr, w_obj) for w_obj in list_w]
-            else:
-                self.values = None
-        if self.values is not None:
-            for node in self.values:
-                node.sync_app_attrs(space)
-
 
 class BinOp(expr):
 
@@ -1151,7 +509,6 @@
         self.op = op
         self.right = right
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 31
 
     def walkabout(self, visitor):
         visitor.visit_BinOp(self)
@@ -1161,14 +518,6 @@
         self.right = self.right.mutate_over(visitor)
         return visitor.visit_BinOp(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 31:
-            self.missing_field(space, ['lineno', 'col_offset', 'left', 'op', 'right'], 'BinOp')
-        else:
-            pass
-        self.left.sync_app_attrs(space)
-        self.right.sync_app_attrs(space)
-
 
 class UnaryOp(expr):
 
@@ -1176,7 +525,6 @@
         self.op = op
         self.operand = operand
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 15
 
     def walkabout(self, visitor):
         visitor.visit_UnaryOp(self)
@@ -1185,13 +533,6 @@
         self.operand = self.operand.mutate_over(visitor)
         return visitor.visit_UnaryOp(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 15:
-            self.missing_field(space, ['lineno', 'col_offset', 'op', 'operand'], 'UnaryOp')
-        else:
-            pass
-        self.operand.sync_app_attrs(space)
-
 
 class Lambda(expr):
 
@@ -1199,7 +540,6 @@
         self.args = args
         self.body = body
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 15
 
     def walkabout(self, visitor):
         visitor.visit_Lambda(self)
@@ -1209,14 +549,6 @@
         self.body = self.body.mutate_over(visitor)
         return visitor.visit_Lambda(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 15:
-            self.missing_field(space, ['lineno', 'col_offset', 'args', 'body'], 'Lambda')
-        else:
-            pass
-        self.args.sync_app_attrs(space)
-        self.body.sync_app_attrs(space)
-
 
 class IfExp(expr):
 
@@ -1225,7 +557,6 @@
         self.body = body
         self.orelse = orelse
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 31
 
     def walkabout(self, visitor):
         visitor.visit_IfExp(self)
@@ -1236,25 +567,13 @@
         self.orelse = self.orelse.mutate_over(visitor)
         return visitor.visit_IfExp(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 31:
-            self.missing_field(space, ['lineno', 'col_offset', 'test', 'body', 'orelse'], 'IfExp')
-        else:
-            pass
-        self.test.sync_app_attrs(space)
-        self.body.sync_app_attrs(space)
-        self.orelse.sync_app_attrs(space)
-
 
 class Dict(expr):
 
     def __init__(self, keys, values, lineno, col_offset):
         self.keys = keys
-        self.w_keys = None
         self.values = values
-        self.w_values = None
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 15
 
     def walkabout(self, visitor):
         visitor.visit_Dict(self)
@@ -1266,40 +585,12 @@
             visitor._mutate_sequence(self.values)
         return visitor.visit_Dict(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 15:
-            self.missing_field(space, ['lineno', 'col_offset', 'keys', 'values'], 'Dict')
-        else:
-            pass
-        w_list = self.w_keys
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.keys = [space.interp_w(expr, w_obj) for w_obj in list_w]
-            else:
-                self.keys = None
-        if self.keys is not None:
-            for node in self.keys:
-                node.sync_app_attrs(space)
-        w_list = self.w_values
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.values = [space.interp_w(expr, w_obj) for w_obj in list_w]
-            else:
-                self.values = None
-        if self.values is not None:
-            for node in self.values:
-                node.sync_app_attrs(space)
-
 
 class Set(expr):
 
     def __init__(self, elts, lineno, col_offset):
         self.elts = elts
-        self.w_elts = None
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 7
 
     def walkabout(self, visitor):
         visitor.visit_Set(self)
@@ -1309,31 +600,13 @@
             visitor._mutate_sequence(self.elts)
         return visitor.visit_Set(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 7:
-            self.missing_field(space, ['lineno', 'col_offset', 'elts'], 'Set')
-        else:
-            pass
-        w_list = self.w_elts
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.elts = [space.interp_w(expr, w_obj) for w_obj in list_w]
-            else:
-                self.elts = None
-        if self.elts is not None:
-            for node in self.elts:
-                node.sync_app_attrs(space)
-
 
 class ListComp(expr):
 
     def __init__(self, elt, generators, lineno, col_offset):
         self.elt = elt
         self.generators = generators
-        self.w_generators = None
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 15
 
     def walkabout(self, visitor):
         visitor.visit_ListComp(self)
@@ -1344,32 +617,13 @@
             visitor._mutate_sequence(self.generators)
         return visitor.visit_ListComp(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 15:
-            self.missing_field(space, ['lineno', 'col_offset', 'elt', 'generators'], 'ListComp')
-        else:
-            pass
-        self.elt.sync_app_attrs(space)
-        w_list = self.w_generators
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.generators = [space.interp_w(comprehension, w_obj) for w_obj in list_w]
-            else:
-                self.generators = None
-        if self.generators is not None:
-            for node in self.generators:
-                node.sync_app_attrs(space)
-
 
 class SetComp(expr):
 
     def __init__(self, elt, generators, lineno, col_offset):
         self.elt = elt
         self.generators = generators
-        self.w_generators = None
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 15
 
     def walkabout(self, visitor):
         visitor.visit_SetComp(self)
@@ -1380,23 +634,6 @@
             visitor._mutate_sequence(self.generators)
         return visitor.visit_SetComp(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 15:
-            self.missing_field(space, ['lineno', 'col_offset', 'elt', 'generators'], 'SetComp')
-        else:
-            pass
-        self.elt.sync_app_attrs(space)
-        w_list = self.w_generators
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.generators = [space.interp_w(comprehension, w_obj) for w_obj in list_w]
-            else:
-                self.generators = None
-        if self.generators is not None:
-            for node in self.generators:
-                node.sync_app_attrs(space)
-
 
 class DictComp(expr):
 
@@ -1404,9 +641,7 @@
         self.key = key
         self.value = value
         self.generators = generators
-        self.w_generators = None
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 31
 
     def walkabout(self, visitor):
         visitor.visit_DictComp(self)
@@ -1418,33 +653,13 @@
             visitor._mutate_sequence(self.generators)
         return visitor.visit_DictComp(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 31:
-            self.missing_field(space, ['lineno', 'col_offset', 'key', 'value', 'generators'], 'DictComp')
-        else:
-            pass
-        self.key.sync_app_attrs(space)
-        self.value.sync_app_attrs(space)
-        w_list = self.w_generators
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.generators = [space.interp_w(comprehension, w_obj) for w_obj in list_w]
-            else:
-                self.generators = None
-        if self.generators is not None:
-            for node in self.generators:
-                node.sync_app_attrs(space)
-
 
 class GeneratorExp(expr):
 
     def __init__(self, elt, generators, lineno, col_offset):
         self.elt = elt
         self.generators = generators
-        self.w_generators = None
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 15
 
     def walkabout(self, visitor):
         visitor.visit_GeneratorExp(self)
@@ -1455,30 +670,12 @@
             visitor._mutate_sequence(self.generators)
         return visitor.visit_GeneratorExp(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 15:
-            self.missing_field(space, ['lineno', 'col_offset', 'elt', 'generators'], 'GeneratorExp')
-        else:
-            pass
-        self.elt.sync_app_attrs(space)
-        w_list = self.w_generators
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.generators = [space.interp_w(comprehension, w_obj) for w_obj in list_w]
-            else:
-                self.generators = None
-        if self.generators is not None:
-            for node in self.generators:
-                node.sync_app_attrs(space)
-
 
 class Yield(expr):
 
     def __init__(self, value, lineno, col_offset):
         self.value = value
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 7
 
     def walkabout(self, visitor):
         visitor.visit_Yield(self)
@@ -1488,26 +685,14 @@
             self.value = self.value.mutate_over(visitor)
         return visitor.visit_Yield(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~4) ^ 3:
-            self.missing_field(space, ['lineno', 'col_offset', None], 'Yield')
-        else:
-            if not self.initialization_state & 4:
-                self.value = None
-        if self.value:
-            self.value.sync_app_attrs(space)
-
 
 class Compare(expr):
 
     def __init__(self, left, ops, comparators, lineno, col_offset):
         self.left = left
         self.ops = ops
-        self.w_ops = None
         self.comparators = comparators
-        self.w_comparators = None
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 31
 
     def walkabout(self, visitor):
         visitor.visit_Compare(self)
@@ -1518,43 +703,16 @@
             visitor._mutate_sequence(self.comparators)
         return visitor.visit_Compare(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 31:
-            self.missing_field(space, ['lineno', 'col_offset', 'left', 'ops', 'comparators'], 'Compare')
-        else:
-            pass
-        self.left.sync_app_attrs(space)
-        w_list = self.w_ops
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.ops = [space.interp_w(cmpop, w_obj).to_simple_int(space) for w_obj in list_w]
-            else:
-                self.ops = None
-        w_list = self.w_comparators
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.comparators = [space.interp_w(expr, w_obj) for w_obj in list_w]
-            else:
-                self.comparators = None
-        if self.comparators is not None:
-            for node in self.comparators:
-                node.sync_app_attrs(space)
-
 
 class Call(expr):
 
     def __init__(self, func, args, keywords, starargs, kwargs, lineno, col_offset):
         self.func = func
         self.args = args
-        self.w_args = None
         self.keywords = keywords
-        self.w_keywords = None
         self.starargs = starargs
         self.kwargs = kwargs
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 127
 
     def walkabout(self, visitor):
         visitor.visit_Call(self)
@@ -1571,47 +729,12 @@
             self.kwargs = self.kwargs.mutate_over(visitor)
         return visitor.visit_Call(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~96) ^ 31:
-            self.missing_field(space, ['lineno', 'col_offset', 'func', 'args', 'keywords', None, None], 'Call')
-        else:
-            if not self.initialization_state & 32:
-                self.starargs = None
-            if not self.initialization_state & 64:
-                self.kwargs = None
-        self.func.sync_app_attrs(space)
-        w_list = self.w_args
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.args = [space.interp_w(expr, w_obj) for w_obj in list_w]
-            else:
-                self.args = None
-        if self.args is not None:
-            for node in self.args:
-                node.sync_app_attrs(space)
-        w_list = self.w_keywords
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.keywords = [space.interp_w(keyword, w_obj) for w_obj in list_w]
-            else:
-                self.keywords = None
-        if self.keywords is not None:
-            for node in self.keywords:
-                node.sync_app_attrs(space)
-        if self.starargs:
-            self.starargs.sync_app_attrs(space)
-        if self.kwargs:
-            self.kwargs.sync_app_attrs(space)
-
 
 class Repr(expr):
 
     def __init__(self, value, lineno, col_offset):
         self.value = value
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 7
 
     def walkabout(self, visitor):
         visitor.visit_Repr(self)
@@ -1620,20 +743,12 @@
         self.value = self.value.mutate_over(visitor)
         return visitor.visit_Repr(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 7:
-            self.missing_field(space, ['lineno', 'col_offset', 'value'], 'Repr')
-        else:
-            pass
-        self.value.sync_app_attrs(space)
-
 
 class Num(expr):
 
     def __init__(self, n, lineno, col_offset):
         self.n = n
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 7
 
     def walkabout(self, visitor):
         visitor.visit_Num(self)
@@ -1641,19 +756,12 @@
     def mutate_over(self, visitor):
         return visitor.visit_Num(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 7:
-            self.missing_field(space, ['lineno', 'col_offset', 'n'], 'Num')
-        else:
-            pass
-
 
 class Str(expr):
 
     def __init__(self, s, lineno, col_offset):
         self.s = s
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 7
 
     def walkabout(self, visitor):
         visitor.visit_Str(self)
@@ -1661,12 +769,6 @@
     def mutate_over(self, visitor):
         return visitor.visit_Str(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 7:
-            self.missing_field(space, ['lineno', 'col_offset', 's'], 'Str')
-        else:
-            pass
-
 
 class Attribute(expr):
 
@@ -1675,7 +777,6 @@
         self.attr = attr
         self.ctx = ctx
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 31
 
     def walkabout(self, visitor):
         visitor.visit_Attribute(self)
@@ -1684,13 +785,6 @@
         self.value = self.value.mutate_over(visitor)
         return visitor.visit_Attribute(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 31:
-            self.missing_field(space, ['lineno', 'col_offset', 'value', 'attr', 'ctx'], 'Attribute')
-        else:
-            pass
-        self.value.sync_app_attrs(space)
-
 
 class Subscript(expr):
 
@@ -1699,7 +793,6 @@
         self.slice = slice
         self.ctx = ctx
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 31
 
     def walkabout(self, visitor):
         visitor.visit_Subscript(self)
@@ -1709,14 +802,6 @@
         self.slice = self.slice.mutate_over(visitor)
         return visitor.visit_Subscript(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 31:
-            self.missing_field(space, ['lineno', 'col_offset', 'value', 'slice', 'ctx'], 'Subscript')
-        else:
-            pass
-        self.value.sync_app_attrs(space)
-        self.slice.sync_app_attrs(space)
-
 
 class Name(expr):
 
@@ -1724,7 +809,6 @@
         self.id = id
         self.ctx = ctx
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 15
 
     def walkabout(self, visitor):
         visitor.visit_Name(self)
@@ -1732,21 +816,13 @@
     def mutate_over(self, visitor):
         return visitor.visit_Name(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 15:
-            self.missing_field(space, ['lineno', 'col_offset', 'id', 'ctx'], 'Name')
-        else:
-            pass
-
 
 class List(expr):
 
     def __init__(self, elts, ctx, lineno, col_offset):
         self.elts = elts
-        self.w_elts = None
         self.ctx = ctx
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 15
 
     def walkabout(self, visitor):
         visitor.visit_List(self)
@@ -1756,31 +832,13 @@
             visitor._mutate_sequence(self.elts)
         return visitor.visit_List(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 15:
-            self.missing_field(space, ['lineno', 'col_offset', 'elts', 'ctx'], 'List')
-        else:
-            pass
-        w_list = self.w_elts
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.elts = [space.interp_w(expr, w_obj) for w_obj in list_w]
-            else:
-                self.elts = None
-        if self.elts is not None:
-            for node in self.elts:
-                node.sync_app_attrs(space)
-
 
 class Tuple(expr):
 
     def __init__(self, elts, ctx, lineno, col_offset):
         self.elts = elts
-        self.w_elts = None
         self.ctx = ctx
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 15
 
     def walkabout(self, visitor):
         visitor.visit_Tuple(self)
@@ -1790,29 +848,12 @@
             visitor._mutate_sequence(self.elts)
         return visitor.visit_Tuple(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 15:
-            self.missing_field(space, ['lineno', 'col_offset', 'elts', 'ctx'], 'Tuple')
-        else:
-            pass
-        w_list = self.w_elts
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.elts = [space.interp_w(expr, w_obj) for w_obj in list_w]
-            else:
-                self.elts = None
-        if self.elts is not None:
-            for node in self.elts:
-                node.sync_app_attrs(space)
-
 
 class Const(expr):
 
     def __init__(self, value, lineno, col_offset):
         self.value = value
         expr.__init__(self, lineno, col_offset)
-        self.initialization_state = 7
 
     def walkabout(self, visitor):
         visitor.visit_Const(self)
@@ -1820,12 +861,6 @@
     def mutate_over(self, visitor):
         return visitor.visit_Const(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 7:
-            self.missing_field(space, ['lineno', 'col_offset', 'value'], 'Const')
-        else:
-            pass
-
 
 class expr_context(AST):
 
@@ -1884,8 +919,6 @@
 
 class Ellipsis(slice):
 
-    def __init__(self):
-        self.initialization_state = 0
 
     def walkabout(self, visitor):
         visitor.visit_Ellipsis(self)
@@ -1893,12 +926,6 @@
     def mutate_over(self, visitor):
         return visitor.visit_Ellipsis(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 0:
-            self.missing_field(space, [], 'Ellipsis')
-        else:
-            pass
-
 
 class Slice(slice):
 
@@ -1906,7 +933,6 @@
         self.lower = lower
         self.upper = upper
         self.step = step
-        self.initialization_state = 7
 
     def walkabout(self, visitor):
         visitor.visit_Slice(self)
@@ -1920,30 +946,11 @@
             self.step = self.step.mutate_over(visitor)
         return visitor.visit_Slice(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~7) ^ 0:
-            self.missing_field(space, [None, None, None], 'Slice')
-        else:
-            if not self.initialization_state & 1:
-                self.lower = None
-            if not self.initialization_state & 2:
-                self.upper = None
-            if not self.initialization_state & 4:
-                self.step = None
-        if self.lower:
-            self.lower.sync_app_attrs(space)
-        if self.upper:
-            self.upper.sync_app_attrs(space)
-        if self.step:
-            self.step.sync_app_attrs(space)
-
 
 class ExtSlice(slice):
 
     def __init__(self, dims):
         self.dims = dims
-        self.w_dims = None
-        self.initialization_state = 1
 
     def walkabout(self, visitor):
         visitor.visit_ExtSlice(self)
@@ -1953,28 +960,11 @@
             visitor._mutate_sequence(self.dims)
         return visitor.visit_ExtSlice(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 1:
-            self.missing_field(space, ['dims'], 'ExtSlice')
-        else:
-            pass
-        w_list = self.w_dims
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.dims = [space.interp_w(slice, w_obj) for w_obj in list_w]
-            else:
-                self.dims = None
-        if self.dims is not None:
-            for node in self.dims:
-                node.sync_app_attrs(space)
-
 
 class Index(slice):
 
     def __init__(self, value):
         self.value = value
-        self.initialization_state = 1
 
     def walkabout(self, visitor):
         visitor.visit_Index(self)
@@ -1983,13 +973,6 @@
         self.value = self.value.mutate_over(visitor)
         return visitor.visit_Index(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 1:
-            self.missing_field(space, ['value'], 'Index')
-        else:
-            pass
-        self.value.sync_app_attrs(space)
-
 
 class boolop(AST):
 
@@ -2233,8 +1216,6 @@
         self.target = target
         self.iter = iter
         self.ifs = ifs
-        self.w_ifs = None
-        self.initialization_state = 7
 
     def mutate_over(self, visitor):
         self.target = self.target.mutate_over(visitor)
@@ -2246,24 +1227,6 @@
     def walkabout(self, visitor):
         visitor.visit_comprehension(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 7:
-            self.missing_field(space, ['target', 'iter', 'ifs'], 'comprehension')
-        else:
-            pass
-        self.target.sync_app_attrs(space)
-        self.iter.sync_app_attrs(space)
-        w_list = self.w_ifs
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.ifs = [space.interp_w(expr, w_obj) for w_obj in list_w]
-            else:
-                self.ifs = None
-        if self.ifs is not None:
-            for node in self.ifs:
-                node.sync_app_attrs(space)
-
 class excepthandler(AST):
 
     def __init__(self, lineno, col_offset):
@@ -2276,9 +1239,7 @@
         self.type = type
         self.name = name
         self.body = body
-        self.w_body = None
         excepthandler.__init__(self, lineno, col_offset)
-        self.initialization_state = 31
 
     def walkabout(self, visitor):
         visitor.visit_ExceptHandler(self)
@@ -2292,40 +1253,14 @@
             visitor._mutate_sequence(self.body)
         return visitor.visit_ExceptHandler(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~12) ^ 19:
-            self.missing_field(space, ['lineno', 'col_offset', None, None, 'body'], 'ExceptHandler')
-        else:
-            if not self.initialization_state & 4:
-                self.type = None
-            if not self.initialization_state & 8:
-                self.name = None
-        if self.type:
-            self.type.sync_app_attrs(space)
-        if self.name:
-            self.name.sync_app_attrs(space)
-        w_list = self.w_body
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
-            else:
-                self.body = None
-        if self.body is not None:
-            for node in self.body:
-                node.sync_app_attrs(space)
-
 
 class arguments(AST):
 
     def __init__(self, args, vararg, kwarg, defaults):
         self.args = args
-        self.w_args = None
         self.vararg = vararg
         self.kwarg = kwarg
         self.defaults = defaults
-        self.w_defaults = None
-        self.initialization_state = 15
 
     def mutate_over(self, visitor):
         if self.args:
@@ -2337,41 +1272,11 @@
     def walkabout(self, visitor):
         visitor.visit_arguments(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~6) ^ 9:
-            self.missing_field(space, ['args', None, None, 'defaults'], 'arguments')
-        else:
-            if not self.initialization_state & 2:
-                self.vararg = None
-            if not self.initialization_state & 4:
-                self.kwarg = None
-        w_list = self.w_args
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.args = [space.interp_w(expr, w_obj) for w_obj in list_w]
-            else:
-                self.args = None
-        if self.args is not None:
-            for node in self.args:
-                node.sync_app_attrs(space)
-        w_list = self.w_defaults
-        if w_list is not None:
-            list_w = space.listview(w_list)
-            if list_w:
-                self.defaults = [space.interp_w(expr, w_obj) for w_obj in list_w]
-            else:
-                self.defaults = None
-        if self.defaults is not None:
-            for node in self.defaults:
-                node.sync_app_attrs(space)
-
 class keyword(AST):
 
     def __init__(self, arg, value):
         self.arg = arg
         self.value = value
-        self.initialization_state = 3
 
     def mutate_over(self, visitor):
         self.value = self.value.mutate_over(visitor)
@@ -2380,19 +1285,11 @@
     def walkabout(self, visitor):
         visitor.visit_keyword(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~0) ^ 3:
-            self.missing_field(space, ['arg', 'value'], 'keyword')
-        else:
-            pass
-        self.value.sync_app_attrs(space)
-
 class alias(AST):
 
     def __init__(self, name, asname):
         self.name = name
         self.asname = asname
-        self.initialization_state = 3
 
     def mutate_over(self, visitor):
         return visitor.visit_alias(self)
@@ -2400,13 +1297,6 @@
     def walkabout(self, visitor):
         visitor.visit_alias(self)
 
-    def sync_app_attrs(self, space):
-        if (self.initialization_state & ~2) ^ 1:
-            self.missing_field(space, ['name', None], 'alias')
-        else:
-            if not self.initialization_state & 2:
-                self.asname = None
-
 class ASTVisitor(object):
 
     def visit_sequence(self, seq):
@@ -2784,4412 +1674,3 @@
         pass
 
 
-mod.typedef = typedef.TypeDef("mod",
-    AST.typedef,
-    __module__='_ast',
-    _attributes=_FieldsWrapper([]),
-    __new__=interp2app(get_AST_new(mod)),
-)
-
-def Module_get_body(space, w_self):
-    if not w_self.initialization_state & 1:
-        raise operationerrfmt(space.w_AttributeError, "'%T' object has no attribute '%s'", w_self, 'body')
-    if w_self.w_body is None:
-        if w_self.body is None:
-            list_w = []
-        else:
-            list_w = [space.wrap(node) for node in w_self.body]
-        w_list = space.newlist(list_w)
-        w_self.w_body = w_list
-    return w_self.w_body
-
-def Module_set_body(space, w_self, w_new_value):
-    w_self.w_body = w_new_value
-    w_self.initialization_state |= 1
-
-_Module_field_unroller = unrolling_iterable(['body'])
-def Module_init(space, w_self, __args__):
-    w_self = space.descr_self_interp_w(Module, w_self)
-    w_self.w_body = None
-    args_w, kwargs_w = __args__.unpack()
-    if args_w:
-        if len(args_w) != 1:
-            w_err = space.wrap("Module constructor takes either 0 or 1 positional argument")
-            raise OperationError(space.w_TypeError, w_err)
-        i = 0
-        for field in _Module_field_unroller:
-            space.setattr(w_self, space.wrap(field), args_w[i])
-            i += 1
-    for field, w_value in kwargs_w.iteritems():
-        space.setattr(w_self, space.wrap(field), w_value)
-
-Module.typedef = typedef.TypeDef("Module",
-    mod.typedef,
-    __module__='_ast',
-    _fields=_FieldsWrapper(['body']),
-    body=typedef.GetSetProperty(Module_get_body, Module_set_body, cls=Module),
-    __new__=interp2app(get_AST_new(Module)),


More information about the pypy-commit mailing list