1. Pypy
  2. Untitled project
  3. pypy

Commits

Armin Rigo  committed 2a86e6f

Patch by dmlockhart: support delattr() on ast node objects.

  • Participants
  • Parent commits 3f9e48c
  • Branches default

Comments (0)

Files changed (3)

File pypy/interpreter/astcompiler/ast.py

View file
  • Ignore whitespace
     w_self.w_body = w_new_value
     w_self.initialization_state |= 1
 
+def Module_del_body(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Module_get_body(space, w_self)
+    w_self.deldictvalue(space, 'body')
+    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)
     mod.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['body']),
-    body=typedef.GetSetProperty(Module_get_body, Module_set_body, cls=Module),
+    body=typedef.GetSetProperty(Module_get_body, Module_set_body, Module_del_body, cls=Module),
     __new__=interp2app(get_AST_new(Module)),
     __init__=interp2app(Module_init),
 )
     w_self.w_body = w_new_value
     w_self.initialization_state |= 1
 
+def Interactive_del_body(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Interactive_get_body(space, w_self)
+    w_self.deldictvalue(space, 'body')
+    w_self.initialization_state &= ~1
+
 _Interactive_field_unroller = unrolling_iterable(['body'])
 def Interactive_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Interactive, w_self)
     mod.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['body']),
-    body=typedef.GetSetProperty(Interactive_get_body, Interactive_set_body, cls=Interactive),
+    body=typedef.GetSetProperty(Interactive_get_body, Interactive_set_body, Interactive_del_body, cls=Interactive),
     __new__=interp2app(get_AST_new(Interactive)),
     __init__=interp2app(Interactive_init),
 )
     w_self.deldictvalue(space, 'body')
     w_self.initialization_state |= 1
 
+def Expression_del_body(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Expression_get_body(space, w_self)
+    w_self.deldictvalue(space, 'body')
+    w_self.initialization_state &= ~1
+
 _Expression_field_unroller = unrolling_iterable(['body'])
 def Expression_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Expression, w_self)
     mod.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['body']),
-    body=typedef.GetSetProperty(Expression_get_body, Expression_set_body, cls=Expression),
+    body=typedef.GetSetProperty(Expression_get_body, Expression_set_body, Expression_del_body, cls=Expression),
     __new__=interp2app(get_AST_new(Expression)),
     __init__=interp2app(Expression_init),
 )
     w_self.w_body = w_new_value
     w_self.initialization_state |= 1
 
+def Suite_del_body(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Suite_get_body(space, w_self)
+    w_self.deldictvalue(space, 'body')
+    w_self.initialization_state &= ~1
+
 _Suite_field_unroller = unrolling_iterable(['body'])
 def Suite_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Suite, w_self)
     mod.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['body']),
-    body=typedef.GetSetProperty(Suite_get_body, Suite_set_body, cls=Suite),
+    body=typedef.GetSetProperty(Suite_get_body, Suite_set_body, Suite_del_body, cls=Suite),
     __new__=interp2app(get_AST_new(Suite)),
     __init__=interp2app(Suite_init),
 )
     w_self.deldictvalue(space, 'lineno')
     w_self.initialization_state |= 1
 
+def stmt_del_lineno(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    stmt_get_lineno(space, w_self)
+    w_self.deldictvalue(space, 'lineno')
+    w_self.initialization_state &= ~1
+
 def stmt_get_col_offset(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'col_offset')
     w_self.deldictvalue(space, 'col_offset')
     w_self.initialization_state |= 2
 
+def stmt_del_col_offset(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    stmt_get_col_offset(space, w_self)
+    w_self.deldictvalue(space, 'col_offset')
+    w_self.initialization_state &= ~2
+
 stmt.typedef = typedef.TypeDef("stmt",
     AST.typedef,
     __module__='_ast',
     _attributes=_FieldsWrapper(['lineno', 'col_offset']),
-    lineno=typedef.GetSetProperty(stmt_get_lineno, stmt_set_lineno, cls=stmt),
-    col_offset=typedef.GetSetProperty(stmt_get_col_offset, stmt_set_col_offset, cls=stmt),
+    lineno=typedef.GetSetProperty(stmt_get_lineno, stmt_set_lineno, stmt_del_lineno, cls=stmt),
+    col_offset=typedef.GetSetProperty(stmt_get_col_offset, stmt_set_col_offset, stmt_del_col_offset, cls=stmt),
     __new__=interp2app(get_AST_new(stmt)),
 )
 
     w_self.deldictvalue(space, 'name')
     w_self.initialization_state |= 4
 
+def FunctionDef_del_name(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    FunctionDef_get_name(space, w_self)
+    w_self.deldictvalue(space, 'name')
+    w_self.initialization_state &= ~4
+
 def FunctionDef_get_args(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'args')
     w_self.deldictvalue(space, 'args')
     w_self.initialization_state |= 8
 
+def FunctionDef_del_args(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    FunctionDef_get_args(space, w_self)
+    w_self.deldictvalue(space, 'args')
+    w_self.initialization_state &= ~8
+
 def FunctionDef_get_body(space, w_self):
     if not w_self.initialization_state & 16:
         raise_attriberr(space, w_self, 'body')
     w_self.w_body = w_new_value
     w_self.initialization_state |= 16
 
+def FunctionDef_del_body(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    FunctionDef_get_body(space, w_self)
+    w_self.deldictvalue(space, 'body')
+    w_self.initialization_state &= ~16
+
 def FunctionDef_get_decorator_list(space, w_self):
     if not w_self.initialization_state & 32:
         raise_attriberr(space, w_self, 'decorator_list')
     w_self.w_decorator_list = w_new_value
     w_self.initialization_state |= 32
 
+def FunctionDef_del_decorator_list(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    FunctionDef_get_decorator_list(space, w_self)
+    w_self.deldictvalue(space, 'decorator_list')
+    w_self.initialization_state &= ~32
+
 _FunctionDef_field_unroller = unrolling_iterable(['name', 'args', 'body', 'decorator_list'])
 def FunctionDef_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(FunctionDef, w_self)
     stmt.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['name', 'args', 'body', 'decorator_list']),
-    name=typedef.GetSetProperty(FunctionDef_get_name, FunctionDef_set_name, cls=FunctionDef),
-    args=typedef.GetSetProperty(FunctionDef_get_args, FunctionDef_set_args, cls=FunctionDef),
-    body=typedef.GetSetProperty(FunctionDef_get_body, FunctionDef_set_body, cls=FunctionDef),
-    decorator_list=typedef.GetSetProperty(FunctionDef_get_decorator_list, FunctionDef_set_decorator_list, cls=FunctionDef),
+    name=typedef.GetSetProperty(FunctionDef_get_name, FunctionDef_set_name, FunctionDef_del_name, cls=FunctionDef),
+    args=typedef.GetSetProperty(FunctionDef_get_args, FunctionDef_set_args, FunctionDef_del_args, cls=FunctionDef),
+    body=typedef.GetSetProperty(FunctionDef_get_body, FunctionDef_set_body, FunctionDef_del_body, cls=FunctionDef),
+    decorator_list=typedef.GetSetProperty(FunctionDef_get_decorator_list, FunctionDef_set_decorator_list, FunctionDef_del_decorator_list, cls=FunctionDef),
     __new__=interp2app(get_AST_new(FunctionDef)),
     __init__=interp2app(FunctionDef_init),
 )
     w_self.deldictvalue(space, 'name')
     w_self.initialization_state |= 4
 
+def ClassDef_del_name(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    ClassDef_get_name(space, w_self)
+    w_self.deldictvalue(space, 'name')
+    w_self.initialization_state &= ~4
+
 def ClassDef_get_bases(space, w_self):
     if not w_self.initialization_state & 8:
         raise_attriberr(space, w_self, 'bases')
     w_self.w_bases = w_new_value
     w_self.initialization_state |= 8
 
+def ClassDef_del_bases(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    ClassDef_get_bases(space, w_self)
+    w_self.deldictvalue(space, 'bases')
+    w_self.initialization_state &= ~8
+
 def ClassDef_get_body(space, w_self):
     if not w_self.initialization_state & 16:
         raise_attriberr(space, w_self, 'body')
     w_self.w_body = w_new_value
     w_self.initialization_state |= 16
 
+def ClassDef_del_body(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    ClassDef_get_body(space, w_self)
+    w_self.deldictvalue(space, 'body')
+    w_self.initialization_state &= ~16
+
 def ClassDef_get_decorator_list(space, w_self):
     if not w_self.initialization_state & 32:
         raise_attriberr(space, w_self, 'decorator_list')
     w_self.w_decorator_list = w_new_value
     w_self.initialization_state |= 32
 
+def ClassDef_del_decorator_list(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    ClassDef_get_decorator_list(space, w_self)
+    w_self.deldictvalue(space, 'decorator_list')
+    w_self.initialization_state &= ~32
+
 _ClassDef_field_unroller = unrolling_iterable(['name', 'bases', 'body', 'decorator_list'])
 def ClassDef_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(ClassDef, w_self)
     stmt.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['name', 'bases', 'body', 'decorator_list']),
-    name=typedef.GetSetProperty(ClassDef_get_name, ClassDef_set_name, cls=ClassDef),
-    bases=typedef.GetSetProperty(ClassDef_get_bases, ClassDef_set_bases, cls=ClassDef),
-    body=typedef.GetSetProperty(ClassDef_get_body, ClassDef_set_body, cls=ClassDef),
-    decorator_list=typedef.GetSetProperty(ClassDef_get_decorator_list, ClassDef_set_decorator_list, cls=ClassDef),
+    name=typedef.GetSetProperty(ClassDef_get_name, ClassDef_set_name, ClassDef_del_name, cls=ClassDef),
+    bases=typedef.GetSetProperty(ClassDef_get_bases, ClassDef_set_bases, ClassDef_del_bases, cls=ClassDef),
+    body=typedef.GetSetProperty(ClassDef_get_body, ClassDef_set_body, ClassDef_del_body, cls=ClassDef),
+    decorator_list=typedef.GetSetProperty(ClassDef_get_decorator_list, ClassDef_set_decorator_list, ClassDef_del_decorator_list, cls=ClassDef),
     __new__=interp2app(get_AST_new(ClassDef)),
     __init__=interp2app(ClassDef_init),
 )
     w_self.deldictvalue(space, 'value')
     w_self.initialization_state |= 4
 
+def Return_del_value(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Return_get_value(space, w_self)
+    w_self.deldictvalue(space, 'value')
+    w_self.initialization_state &= ~4
+
 _Return_field_unroller = unrolling_iterable(['value'])
 def Return_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Return, w_self)
     stmt.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['value']),
-    value=typedef.GetSetProperty(Return_get_value, Return_set_value, cls=Return),
+    value=typedef.GetSetProperty(Return_get_value, Return_set_value, Return_del_value, cls=Return),
     __new__=interp2app(get_AST_new(Return)),
     __init__=interp2app(Return_init),
 )
     w_self.w_targets = w_new_value
     w_self.initialization_state |= 4
 
+def Delete_del_targets(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Delete_get_targets(space, w_self)
+    w_self.deldictvalue(space, 'targets')
+    w_self.initialization_state &= ~4
+
 _Delete_field_unroller = unrolling_iterable(['targets'])
 def Delete_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Delete, w_self)
     stmt.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['targets']),
-    targets=typedef.GetSetProperty(Delete_get_targets, Delete_set_targets, cls=Delete),
+    targets=typedef.GetSetProperty(Delete_get_targets, Delete_set_targets, Delete_del_targets, cls=Delete),
     __new__=interp2app(get_AST_new(Delete)),
     __init__=interp2app(Delete_init),
 )
     w_self.w_targets = w_new_value
     w_self.initialization_state |= 4
 
+def Assign_del_targets(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Assign_get_targets(space, w_self)
+    w_self.deldictvalue(space, 'targets')
+    w_self.initialization_state &= ~4
+
 def Assign_get_value(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'value')
     w_self.deldictvalue(space, 'value')
     w_self.initialization_state |= 8
 
+def Assign_del_value(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Assign_get_value(space, w_self)
+    w_self.deldictvalue(space, 'value')
+    w_self.initialization_state &= ~8
+
 _Assign_field_unroller = unrolling_iterable(['targets', 'value'])
 def Assign_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Assign, w_self)
     stmt.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['targets', 'value']),
-    targets=typedef.GetSetProperty(Assign_get_targets, Assign_set_targets, cls=Assign),
-    value=typedef.GetSetProperty(Assign_get_value, Assign_set_value, cls=Assign),
+    targets=typedef.GetSetProperty(Assign_get_targets, Assign_set_targets, Assign_del_targets, cls=Assign),
+    value=typedef.GetSetProperty(Assign_get_value, Assign_set_value, Assign_del_value, cls=Assign),
     __new__=interp2app(get_AST_new(Assign)),
     __init__=interp2app(Assign_init),
 )
     w_self.deldictvalue(space, 'target')
     w_self.initialization_state |= 4
 
+def AugAssign_del_target(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    AugAssign_get_target(space, w_self)
+    w_self.deldictvalue(space, 'target')
+    w_self.initialization_state &= ~4
+
 def AugAssign_get_op(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'op')
     w_self.setdictvalue(space, 'op', w_new_value)
     w_self.initialization_state |= 8
 
+def AugAssign_del_op(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    AugAssign_get_op(space, w_self)
+    w_self.deldictvalue(space, 'op')
+    w_self.initialization_state &= ~8
+
 def AugAssign_get_value(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'value')
     w_self.deldictvalue(space, 'value')
     w_self.initialization_state |= 16
 
+def AugAssign_del_value(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    AugAssign_get_value(space, w_self)
+    w_self.deldictvalue(space, 'value')
+    w_self.initialization_state &= ~16
+
 _AugAssign_field_unroller = unrolling_iterable(['target', 'op', 'value'])
 def AugAssign_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(AugAssign, w_self)
     stmt.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['target', 'op', 'value']),
-    target=typedef.GetSetProperty(AugAssign_get_target, AugAssign_set_target, cls=AugAssign),
-    op=typedef.GetSetProperty(AugAssign_get_op, AugAssign_set_op, cls=AugAssign),
-    value=typedef.GetSetProperty(AugAssign_get_value, AugAssign_set_value, cls=AugAssign),
+    target=typedef.GetSetProperty(AugAssign_get_target, AugAssign_set_target, AugAssign_del_target, cls=AugAssign),
+    op=typedef.GetSetProperty(AugAssign_get_op, AugAssign_set_op, AugAssign_del_op, cls=AugAssign),
+    value=typedef.GetSetProperty(AugAssign_get_value, AugAssign_set_value, AugAssign_del_value, cls=AugAssign),
     __new__=interp2app(get_AST_new(AugAssign)),
     __init__=interp2app(AugAssign_init),
 )
     w_self.deldictvalue(space, 'dest')
     w_self.initialization_state |= 4
 
+def Print_del_dest(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Print_get_dest(space, w_self)
+    w_self.deldictvalue(space, 'dest')
+    w_self.initialization_state &= ~4
+
 def Print_get_values(space, w_self):
     if not w_self.initialization_state & 8:
         raise_attriberr(space, w_self, 'values')
     w_self.w_values = w_new_value
     w_self.initialization_state |= 8
 
+def Print_del_values(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Print_get_values(space, w_self)
+    w_self.deldictvalue(space, 'values')
+    w_self.initialization_state &= ~8
+
 def Print_get_nl(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'nl')
     w_self.deldictvalue(space, 'nl')
     w_self.initialization_state |= 16
 
+def Print_del_nl(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Print_get_nl(space, w_self)
+    w_self.deldictvalue(space, 'nl')
+    w_self.initialization_state &= ~16
+
 _Print_field_unroller = unrolling_iterable(['dest', 'values', 'nl'])
 def Print_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Print, w_self)
     stmt.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['dest', 'values', 'nl']),
-    dest=typedef.GetSetProperty(Print_get_dest, Print_set_dest, cls=Print),
-    values=typedef.GetSetProperty(Print_get_values, Print_set_values, cls=Print),
-    nl=typedef.GetSetProperty(Print_get_nl, Print_set_nl, cls=Print),
+    dest=typedef.GetSetProperty(Print_get_dest, Print_set_dest, Print_del_dest, cls=Print),
+    values=typedef.GetSetProperty(Print_get_values, Print_set_values, Print_del_values, cls=Print),
+    nl=typedef.GetSetProperty(Print_get_nl, Print_set_nl, Print_del_nl, cls=Print),
     __new__=interp2app(get_AST_new(Print)),
     __init__=interp2app(Print_init),
 )
     w_self.deldictvalue(space, 'target')
     w_self.initialization_state |= 4
 
+def For_del_target(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    For_get_target(space, w_self)
+    w_self.deldictvalue(space, 'target')
+    w_self.initialization_state &= ~4
+
 def For_get_iter(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'iter')
     w_self.deldictvalue(space, 'iter')
     w_self.initialization_state |= 8
 
+def For_del_iter(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    For_get_iter(space, w_self)
+    w_self.deldictvalue(space, 'iter')
+    w_self.initialization_state &= ~8
+
 def For_get_body(space, w_self):
     if not w_self.initialization_state & 16:
         raise_attriberr(space, w_self, 'body')
     w_self.w_body = w_new_value
     w_self.initialization_state |= 16
 
+def For_del_body(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    For_get_body(space, w_self)
+    w_self.deldictvalue(space, 'body')
+    w_self.initialization_state &= ~16
+
 def For_get_orelse(space, w_self):
     if not w_self.initialization_state & 32:
         raise_attriberr(space, w_self, 'orelse')
     w_self.w_orelse = w_new_value
     w_self.initialization_state |= 32
 
+def For_del_orelse(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    For_get_orelse(space, w_self)
+    w_self.deldictvalue(space, 'orelse')
+    w_self.initialization_state &= ~32
+
 _For_field_unroller = unrolling_iterable(['target', 'iter', 'body', 'orelse'])
 def For_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(For, w_self)
     stmt.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['target', 'iter', 'body', 'orelse']),
-    target=typedef.GetSetProperty(For_get_target, For_set_target, cls=For),
-    iter=typedef.GetSetProperty(For_get_iter, For_set_iter, cls=For),
-    body=typedef.GetSetProperty(For_get_body, For_set_body, cls=For),
-    orelse=typedef.GetSetProperty(For_get_orelse, For_set_orelse, cls=For),
+    target=typedef.GetSetProperty(For_get_target, For_set_target, For_del_target, cls=For),
+    iter=typedef.GetSetProperty(For_get_iter, For_set_iter, For_del_iter, cls=For),
+    body=typedef.GetSetProperty(For_get_body, For_set_body, For_del_body, cls=For),
+    orelse=typedef.GetSetProperty(For_get_orelse, For_set_orelse, For_del_orelse, cls=For),
     __new__=interp2app(get_AST_new(For)),
     __init__=interp2app(For_init),
 )
     w_self.deldictvalue(space, 'test')
     w_self.initialization_state |= 4
 
+def While_del_test(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    While_get_test(space, w_self)
+    w_self.deldictvalue(space, 'test')
+    w_self.initialization_state &= ~4
+
 def While_get_body(space, w_self):
     if not w_self.initialization_state & 8:
         raise_attriberr(space, w_self, 'body')
     w_self.w_body = w_new_value
     w_self.initialization_state |= 8
 
+def While_del_body(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    While_get_body(space, w_self)
+    w_self.deldictvalue(space, 'body')
+    w_self.initialization_state &= ~8
+
 def While_get_orelse(space, w_self):
     if not w_self.initialization_state & 16:
         raise_attriberr(space, w_self, 'orelse')
     w_self.w_orelse = w_new_value
     w_self.initialization_state |= 16
 
+def While_del_orelse(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    While_get_orelse(space, w_self)
+    w_self.deldictvalue(space, 'orelse')
+    w_self.initialization_state &= ~16
+
 _While_field_unroller = unrolling_iterable(['test', 'body', 'orelse'])
 def While_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(While, w_self)
     stmt.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['test', 'body', 'orelse']),
-    test=typedef.GetSetProperty(While_get_test, While_set_test, cls=While),
-    body=typedef.GetSetProperty(While_get_body, While_set_body, cls=While),
-    orelse=typedef.GetSetProperty(While_get_orelse, While_set_orelse, cls=While),
+    test=typedef.GetSetProperty(While_get_test, While_set_test, While_del_test, cls=While),
+    body=typedef.GetSetProperty(While_get_body, While_set_body, While_del_body, cls=While),
+    orelse=typedef.GetSetProperty(While_get_orelse, While_set_orelse, While_del_orelse, cls=While),
     __new__=interp2app(get_AST_new(While)),
     __init__=interp2app(While_init),
 )
     w_self.deldictvalue(space, 'test')
     w_self.initialization_state |= 4
 
+def If_del_test(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    If_get_test(space, w_self)
+    w_self.deldictvalue(space, 'test')
+    w_self.initialization_state &= ~4
+
 def If_get_body(space, w_self):
     if not w_self.initialization_state & 8:
         raise_attriberr(space, w_self, 'body')
     w_self.w_body = w_new_value
     w_self.initialization_state |= 8
 
+def If_del_body(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    If_get_body(space, w_self)
+    w_self.deldictvalue(space, 'body')
+    w_self.initialization_state &= ~8
+
 def If_get_orelse(space, w_self):
     if not w_self.initialization_state & 16:
         raise_attriberr(space, w_self, 'orelse')
     w_self.w_orelse = w_new_value
     w_self.initialization_state |= 16
 
+def If_del_orelse(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    If_get_orelse(space, w_self)
+    w_self.deldictvalue(space, 'orelse')
+    w_self.initialization_state &= ~16
+
 _If_field_unroller = unrolling_iterable(['test', 'body', 'orelse'])
 def If_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(If, w_self)
     stmt.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['test', 'body', 'orelse']),
-    test=typedef.GetSetProperty(If_get_test, If_set_test, cls=If),
-    body=typedef.GetSetProperty(If_get_body, If_set_body, cls=If),
-    orelse=typedef.GetSetProperty(If_get_orelse, If_set_orelse, cls=If),
+    test=typedef.GetSetProperty(If_get_test, If_set_test, If_del_test, cls=If),
+    body=typedef.GetSetProperty(If_get_body, If_set_body, If_del_body, cls=If),
+    orelse=typedef.GetSetProperty(If_get_orelse, If_set_orelse, If_del_orelse, cls=If),
     __new__=interp2app(get_AST_new(If)),
     __init__=interp2app(If_init),
 )
     w_self.deldictvalue(space, 'context_expr')
     w_self.initialization_state |= 4
 
+def With_del_context_expr(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    With_get_context_expr(space, w_self)
+    w_self.deldictvalue(space, 'context_expr')
+    w_self.initialization_state &= ~4
+
 def With_get_optional_vars(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'optional_vars')
     w_self.deldictvalue(space, 'optional_vars')
     w_self.initialization_state |= 8
 
+def With_del_optional_vars(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    With_get_optional_vars(space, w_self)
+    w_self.deldictvalue(space, 'optional_vars')
+    w_self.initialization_state &= ~8
+
 def With_get_body(space, w_self):
     if not w_self.initialization_state & 16:
         raise_attriberr(space, w_self, 'body')
     w_self.w_body = w_new_value
     w_self.initialization_state |= 16
 
+def With_del_body(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    With_get_body(space, w_self)
+    w_self.deldictvalue(space, 'body')
+    w_self.initialization_state &= ~16
+
 _With_field_unroller = unrolling_iterable(['context_expr', 'optional_vars', 'body'])
 def With_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(With, w_self)
     stmt.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['context_expr', 'optional_vars', 'body']),
-    context_expr=typedef.GetSetProperty(With_get_context_expr, With_set_context_expr, cls=With),
-    optional_vars=typedef.GetSetProperty(With_get_optional_vars, With_set_optional_vars, cls=With),
-    body=typedef.GetSetProperty(With_get_body, With_set_body, cls=With),
+    context_expr=typedef.GetSetProperty(With_get_context_expr, With_set_context_expr, With_del_context_expr, cls=With),
+    optional_vars=typedef.GetSetProperty(With_get_optional_vars, With_set_optional_vars, With_del_optional_vars, cls=With),
+    body=typedef.GetSetProperty(With_get_body, With_set_body, With_del_body, cls=With),
     __new__=interp2app(get_AST_new(With)),
     __init__=interp2app(With_init),
 )
     w_self.deldictvalue(space, 'type')
     w_self.initialization_state |= 4
 
+def Raise_del_type(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Raise_get_type(space, w_self)
+    w_self.deldictvalue(space, 'type')
+    w_self.initialization_state &= ~4
+
 def Raise_get_inst(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'inst')
     w_self.deldictvalue(space, 'inst')
     w_self.initialization_state |= 8
 
+def Raise_del_inst(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Raise_get_inst(space, w_self)
+    w_self.deldictvalue(space, 'inst')
+    w_self.initialization_state &= ~8
+
 def Raise_get_tback(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'tback')
     w_self.deldictvalue(space, 'tback')
     w_self.initialization_state |= 16
 
+def Raise_del_tback(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Raise_get_tback(space, w_self)
+    w_self.deldictvalue(space, 'tback')
+    w_self.initialization_state &= ~16
+
 _Raise_field_unroller = unrolling_iterable(['type', 'inst', 'tback'])
 def Raise_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Raise, w_self)
     stmt.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['type', 'inst', 'tback']),
-    type=typedef.GetSetProperty(Raise_get_type, Raise_set_type, cls=Raise),
-    inst=typedef.GetSetProperty(Raise_get_inst, Raise_set_inst, cls=Raise),
-    tback=typedef.GetSetProperty(Raise_get_tback, Raise_set_tback, cls=Raise),
+    type=typedef.GetSetProperty(Raise_get_type, Raise_set_type, Raise_del_type, cls=Raise),
+    inst=typedef.GetSetProperty(Raise_get_inst, Raise_set_inst, Raise_del_inst, cls=Raise),
+    tback=typedef.GetSetProperty(Raise_get_tback, Raise_set_tback, Raise_del_tback, cls=Raise),
     __new__=interp2app(get_AST_new(Raise)),
     __init__=interp2app(Raise_init),
 )
     w_self.w_body = w_new_value
     w_self.initialization_state |= 4
 
+def TryExcept_del_body(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    TryExcept_get_body(space, w_self)
+    w_self.deldictvalue(space, 'body')
+    w_self.initialization_state &= ~4
+
 def TryExcept_get_handlers(space, w_self):
     if not w_self.initialization_state & 8:
         raise_attriberr(space, w_self, 'handlers')
     w_self.w_handlers = w_new_value
     w_self.initialization_state |= 8
 
+def TryExcept_del_handlers(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    TryExcept_get_handlers(space, w_self)
+    w_self.deldictvalue(space, 'handlers')
+    w_self.initialization_state &= ~8
+
 def TryExcept_get_orelse(space, w_self):
     if not w_self.initialization_state & 16:
         raise_attriberr(space, w_self, 'orelse')
     w_self.w_orelse = w_new_value
     w_self.initialization_state |= 16
 
+def TryExcept_del_orelse(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    TryExcept_get_orelse(space, w_self)
+    w_self.deldictvalue(space, 'orelse')
+    w_self.initialization_state &= ~16
+
 _TryExcept_field_unroller = unrolling_iterable(['body', 'handlers', 'orelse'])
 def TryExcept_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(TryExcept, w_self)
     stmt.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['body', 'handlers', 'orelse']),
-    body=typedef.GetSetProperty(TryExcept_get_body, TryExcept_set_body, cls=TryExcept),
-    handlers=typedef.GetSetProperty(TryExcept_get_handlers, TryExcept_set_handlers, cls=TryExcept),
-    orelse=typedef.GetSetProperty(TryExcept_get_orelse, TryExcept_set_orelse, cls=TryExcept),
+    body=typedef.GetSetProperty(TryExcept_get_body, TryExcept_set_body, TryExcept_del_body, cls=TryExcept),
+    handlers=typedef.GetSetProperty(TryExcept_get_handlers, TryExcept_set_handlers, TryExcept_del_handlers, cls=TryExcept),
+    orelse=typedef.GetSetProperty(TryExcept_get_orelse, TryExcept_set_orelse, TryExcept_del_orelse, cls=TryExcept),
     __new__=interp2app(get_AST_new(TryExcept)),
     __init__=interp2app(TryExcept_init),
 )
     w_self.w_body = w_new_value
     w_self.initialization_state |= 4
 
+def TryFinally_del_body(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    TryFinally_get_body(space, w_self)
+    w_self.deldictvalue(space, 'body')
+    w_self.initialization_state &= ~4
+
 def TryFinally_get_finalbody(space, w_self):
     if not w_self.initialization_state & 8:
         raise_attriberr(space, w_self, 'finalbody')
     w_self.w_finalbody = w_new_value
     w_self.initialization_state |= 8
 
+def TryFinally_del_finalbody(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    TryFinally_get_finalbody(space, w_self)
+    w_self.deldictvalue(space, 'finalbody')
+    w_self.initialization_state &= ~8
+
 _TryFinally_field_unroller = unrolling_iterable(['body', 'finalbody'])
 def TryFinally_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(TryFinally, w_self)
     stmt.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['body', 'finalbody']),
-    body=typedef.GetSetProperty(TryFinally_get_body, TryFinally_set_body, cls=TryFinally),
-    finalbody=typedef.GetSetProperty(TryFinally_get_finalbody, TryFinally_set_finalbody, cls=TryFinally),
+    body=typedef.GetSetProperty(TryFinally_get_body, TryFinally_set_body, TryFinally_del_body, cls=TryFinally),
+    finalbody=typedef.GetSetProperty(TryFinally_get_finalbody, TryFinally_set_finalbody, TryFinally_del_finalbody, cls=TryFinally),
     __new__=interp2app(get_AST_new(TryFinally)),
     __init__=interp2app(TryFinally_init),
 )
     w_self.deldictvalue(space, 'test')
     w_self.initialization_state |= 4
 
+def Assert_del_test(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Assert_get_test(space, w_self)
+    w_self.deldictvalue(space, 'test')
+    w_self.initialization_state &= ~4
+
 def Assert_get_msg(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'msg')
     w_self.deldictvalue(space, 'msg')
     w_self.initialization_state |= 8
 
+def Assert_del_msg(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Assert_get_msg(space, w_self)
+    w_self.deldictvalue(space, 'msg')
+    w_self.initialization_state &= ~8
+
 _Assert_field_unroller = unrolling_iterable(['test', 'msg'])
 def Assert_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Assert, w_self)
     stmt.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['test', 'msg']),
-    test=typedef.GetSetProperty(Assert_get_test, Assert_set_test, cls=Assert),
-    msg=typedef.GetSetProperty(Assert_get_msg, Assert_set_msg, cls=Assert),
+    test=typedef.GetSetProperty(Assert_get_test, Assert_set_test, Assert_del_test, cls=Assert),
+    msg=typedef.GetSetProperty(Assert_get_msg, Assert_set_msg, Assert_del_msg, cls=Assert),
     __new__=interp2app(get_AST_new(Assert)),
     __init__=interp2app(Assert_init),
 )
     w_self.w_names = w_new_value
     w_self.initialization_state |= 4
 
+def Import_del_names(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Import_get_names(space, w_self)
+    w_self.deldictvalue(space, 'names')
+    w_self.initialization_state &= ~4
+
 _Import_field_unroller = unrolling_iterable(['names'])
 def Import_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Import, w_self)
     stmt.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['names']),
-    names=typedef.GetSetProperty(Import_get_names, Import_set_names, cls=Import),
+    names=typedef.GetSetProperty(Import_get_names, Import_set_names, Import_del_names, cls=Import),
     __new__=interp2app(get_AST_new(Import)),
     __init__=interp2app(Import_init),
 )
     w_self.deldictvalue(space, 'module')
     w_self.initialization_state |= 4
 
+def ImportFrom_del_module(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    ImportFrom_get_module(space, w_self)
+    w_self.deldictvalue(space, 'module')
+    w_self.initialization_state &= ~4
+
 def ImportFrom_get_names(space, w_self):
     if not w_self.initialization_state & 8:
         raise_attriberr(space, w_self, 'names')
     w_self.w_names = w_new_value
     w_self.initialization_state |= 8
 
+def ImportFrom_del_names(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    ImportFrom_get_names(space, w_self)
+    w_self.deldictvalue(space, 'names')
+    w_self.initialization_state &= ~8
+
 def ImportFrom_get_level(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'level')
     w_self.deldictvalue(space, 'level')
     w_self.initialization_state |= 16
 
+def ImportFrom_del_level(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    ImportFrom_get_level(space, w_self)
+    w_self.deldictvalue(space, 'level')
+    w_self.initialization_state &= ~16
+
 _ImportFrom_field_unroller = unrolling_iterable(['module', 'names', 'level'])
 def ImportFrom_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(ImportFrom, w_self)
     stmt.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['module', 'names', 'level']),
-    module=typedef.GetSetProperty(ImportFrom_get_module, ImportFrom_set_module, cls=ImportFrom),
-    names=typedef.GetSetProperty(ImportFrom_get_names, ImportFrom_set_names, cls=ImportFrom),
-    level=typedef.GetSetProperty(ImportFrom_get_level, ImportFrom_set_level, cls=ImportFrom),
+    module=typedef.GetSetProperty(ImportFrom_get_module, ImportFrom_set_module, ImportFrom_del_module, cls=ImportFrom),
+    names=typedef.GetSetProperty(ImportFrom_get_names, ImportFrom_set_names, ImportFrom_del_names, cls=ImportFrom),
+    level=typedef.GetSetProperty(ImportFrom_get_level, ImportFrom_set_level, ImportFrom_del_level, cls=ImportFrom),
     __new__=interp2app(get_AST_new(ImportFrom)),
     __init__=interp2app(ImportFrom_init),
 )
     w_self.deldictvalue(space, 'body')
     w_self.initialization_state |= 4
 
+def Exec_del_body(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Exec_get_body(space, w_self)
+    w_self.deldictvalue(space, 'body')
+    w_self.initialization_state &= ~4
+
 def Exec_get_globals(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'globals')
     w_self.deldictvalue(space, 'globals')
     w_self.initialization_state |= 8
 
+def Exec_del_globals(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Exec_get_globals(space, w_self)
+    w_self.deldictvalue(space, 'globals')
+    w_self.initialization_state &= ~8
+
 def Exec_get_locals(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'locals')
     w_self.deldictvalue(space, 'locals')
     w_self.initialization_state |= 16
 
+def Exec_del_locals(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Exec_get_locals(space, w_self)
+    w_self.deldictvalue(space, 'locals')
+    w_self.initialization_state &= ~16
+
 _Exec_field_unroller = unrolling_iterable(['body', 'globals', 'locals'])
 def Exec_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Exec, w_self)
     stmt.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['body', 'globals', 'locals']),
-    body=typedef.GetSetProperty(Exec_get_body, Exec_set_body, cls=Exec),
-    globals=typedef.GetSetProperty(Exec_get_globals, Exec_set_globals, cls=Exec),
-    locals=typedef.GetSetProperty(Exec_get_locals, Exec_set_locals, cls=Exec),
+    body=typedef.GetSetProperty(Exec_get_body, Exec_set_body, Exec_del_body, cls=Exec),
+    globals=typedef.GetSetProperty(Exec_get_globals, Exec_set_globals, Exec_del_globals, cls=Exec),
+    locals=typedef.GetSetProperty(Exec_get_locals, Exec_set_locals, Exec_del_locals, cls=Exec),
     __new__=interp2app(get_AST_new(Exec)),
     __init__=interp2app(Exec_init),
 )
     w_self.w_names = w_new_value
     w_self.initialization_state |= 4
 
+def Global_del_names(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Global_get_names(space, w_self)
+    w_self.deldictvalue(space, 'names')
+    w_self.initialization_state &= ~4
+
 _Global_field_unroller = unrolling_iterable(['names'])
 def Global_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Global, w_self)
     stmt.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['names']),
-    names=typedef.GetSetProperty(Global_get_names, Global_set_names, cls=Global),
+    names=typedef.GetSetProperty(Global_get_names, Global_set_names, Global_del_names, cls=Global),
     __new__=interp2app(get_AST_new(Global)),
     __init__=interp2app(Global_init),
 )
     w_self.deldictvalue(space, 'value')
     w_self.initialization_state |= 4
 
+def Expr_del_value(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Expr_get_value(space, w_self)
+    w_self.deldictvalue(space, 'value')
+    w_self.initialization_state &= ~4
+
 _Expr_field_unroller = unrolling_iterable(['value'])
 def Expr_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Expr, w_self)
     stmt.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['value']),
-    value=typedef.GetSetProperty(Expr_get_value, Expr_set_value, cls=Expr),
+    value=typedef.GetSetProperty(Expr_get_value, Expr_set_value, Expr_del_value, cls=Expr),
     __new__=interp2app(get_AST_new(Expr)),
     __init__=interp2app(Expr_init),
 )
     w_self.deldictvalue(space, 'lineno')
     w_self.initialization_state |= 1
 
+def expr_del_lineno(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    expr_get_lineno(space, w_self)
+    w_self.deldictvalue(space, 'lineno')
+    w_self.initialization_state &= ~1
+
 def expr_get_col_offset(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'col_offset')
     w_self.deldictvalue(space, 'col_offset')
     w_self.initialization_state |= 2
 
+def expr_del_col_offset(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    expr_get_col_offset(space, w_self)
+    w_self.deldictvalue(space, 'col_offset')
+    w_self.initialization_state &= ~2
+
 expr.typedef = typedef.TypeDef("expr",
     AST.typedef,
     __module__='_ast',
     _attributes=_FieldsWrapper(['lineno', 'col_offset']),
-    lineno=typedef.GetSetProperty(expr_get_lineno, expr_set_lineno, cls=expr),
-    col_offset=typedef.GetSetProperty(expr_get_col_offset, expr_set_col_offset, cls=expr),
+    lineno=typedef.GetSetProperty(expr_get_lineno, expr_set_lineno, expr_del_lineno, cls=expr),
+    col_offset=typedef.GetSetProperty(expr_get_col_offset, expr_set_col_offset, expr_del_col_offset, cls=expr),
     __new__=interp2app(get_AST_new(expr)),
 )
 
     w_self.setdictvalue(space, 'op', w_new_value)
     w_self.initialization_state |= 4
 
+def BoolOp_del_op(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    BoolOp_get_op(space, w_self)
+    w_self.deldictvalue(space, 'op')
+    w_self.initialization_state &= ~4
+
 def BoolOp_get_values(space, w_self):
     if not w_self.initialization_state & 8:
         raise_attriberr(space, w_self, 'values')
     w_self.w_values = w_new_value
     w_self.initialization_state |= 8
 
+def BoolOp_del_values(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    BoolOp_get_values(space, w_self)
+    w_self.deldictvalue(space, 'values')
+    w_self.initialization_state &= ~8
+
 _BoolOp_field_unroller = unrolling_iterable(['op', 'values'])
 def BoolOp_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(BoolOp, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['op', 'values']),
-    op=typedef.GetSetProperty(BoolOp_get_op, BoolOp_set_op, cls=BoolOp),
-    values=typedef.GetSetProperty(BoolOp_get_values, BoolOp_set_values, cls=BoolOp),
+    op=typedef.GetSetProperty(BoolOp_get_op, BoolOp_set_op, BoolOp_del_op, cls=BoolOp),
+    values=typedef.GetSetProperty(BoolOp_get_values, BoolOp_set_values, BoolOp_del_values, cls=BoolOp),
     __new__=interp2app(get_AST_new(BoolOp)),
     __init__=interp2app(BoolOp_init),
 )
     w_self.deldictvalue(space, 'left')
     w_self.initialization_state |= 4
 
+def BinOp_del_left(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    BinOp_get_left(space, w_self)
+    w_self.deldictvalue(space, 'left')
+    w_self.initialization_state &= ~4
+
 def BinOp_get_op(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'op')
     w_self.setdictvalue(space, 'op', w_new_value)
     w_self.initialization_state |= 8
 
+def BinOp_del_op(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    BinOp_get_op(space, w_self)
+    w_self.deldictvalue(space, 'op')
+    w_self.initialization_state &= ~8
+
 def BinOp_get_right(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'right')
     w_self.deldictvalue(space, 'right')
     w_self.initialization_state |= 16
 
+def BinOp_del_right(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    BinOp_get_right(space, w_self)
+    w_self.deldictvalue(space, 'right')
+    w_self.initialization_state &= ~16
+
 _BinOp_field_unroller = unrolling_iterable(['left', 'op', 'right'])
 def BinOp_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(BinOp, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['left', 'op', 'right']),
-    left=typedef.GetSetProperty(BinOp_get_left, BinOp_set_left, cls=BinOp),
-    op=typedef.GetSetProperty(BinOp_get_op, BinOp_set_op, cls=BinOp),
-    right=typedef.GetSetProperty(BinOp_get_right, BinOp_set_right, cls=BinOp),
+    left=typedef.GetSetProperty(BinOp_get_left, BinOp_set_left, BinOp_del_left, cls=BinOp),
+    op=typedef.GetSetProperty(BinOp_get_op, BinOp_set_op, BinOp_del_op, cls=BinOp),
+    right=typedef.GetSetProperty(BinOp_get_right, BinOp_set_right, BinOp_del_right, cls=BinOp),
     __new__=interp2app(get_AST_new(BinOp)),
     __init__=interp2app(BinOp_init),
 )
     w_self.setdictvalue(space, 'op', w_new_value)
     w_self.initialization_state |= 4
 
+def UnaryOp_del_op(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    UnaryOp_get_op(space, w_self)
+    w_self.deldictvalue(space, 'op')
+    w_self.initialization_state &= ~4
+
 def UnaryOp_get_operand(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'operand')
     w_self.deldictvalue(space, 'operand')
     w_self.initialization_state |= 8
 
+def UnaryOp_del_operand(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    UnaryOp_get_operand(space, w_self)
+    w_self.deldictvalue(space, 'operand')
+    w_self.initialization_state &= ~8
+
 _UnaryOp_field_unroller = unrolling_iterable(['op', 'operand'])
 def UnaryOp_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(UnaryOp, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['op', 'operand']),
-    op=typedef.GetSetProperty(UnaryOp_get_op, UnaryOp_set_op, cls=UnaryOp),
-    operand=typedef.GetSetProperty(UnaryOp_get_operand, UnaryOp_set_operand, cls=UnaryOp),
+    op=typedef.GetSetProperty(UnaryOp_get_op, UnaryOp_set_op, UnaryOp_del_op, cls=UnaryOp),
+    operand=typedef.GetSetProperty(UnaryOp_get_operand, UnaryOp_set_operand, UnaryOp_del_operand, cls=UnaryOp),
     __new__=interp2app(get_AST_new(UnaryOp)),
     __init__=interp2app(UnaryOp_init),
 )
     w_self.deldictvalue(space, 'args')
     w_self.initialization_state |= 4
 
+def Lambda_del_args(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Lambda_get_args(space, w_self)
+    w_self.deldictvalue(space, 'args')
+    w_self.initialization_state &= ~4
+
 def Lambda_get_body(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'body')
     w_self.deldictvalue(space, 'body')
     w_self.initialization_state |= 8
 
+def Lambda_del_body(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Lambda_get_body(space, w_self)
+    w_self.deldictvalue(space, 'body')
+    w_self.initialization_state &= ~8
+
 _Lambda_field_unroller = unrolling_iterable(['args', 'body'])
 def Lambda_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Lambda, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['args', 'body']),
-    args=typedef.GetSetProperty(Lambda_get_args, Lambda_set_args, cls=Lambda),
-    body=typedef.GetSetProperty(Lambda_get_body, Lambda_set_body, cls=Lambda),
+    args=typedef.GetSetProperty(Lambda_get_args, Lambda_set_args, Lambda_del_args, cls=Lambda),
+    body=typedef.GetSetProperty(Lambda_get_body, Lambda_set_body, Lambda_del_body, cls=Lambda),
     __new__=interp2app(get_AST_new(Lambda)),
     __init__=interp2app(Lambda_init),
 )
     w_self.deldictvalue(space, 'test')
     w_self.initialization_state |= 4
 
+def IfExp_del_test(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    IfExp_get_test(space, w_self)
+    w_self.deldictvalue(space, 'test')
+    w_self.initialization_state &= ~4
+
 def IfExp_get_body(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'body')
     w_self.deldictvalue(space, 'body')
     w_self.initialization_state |= 8
 
+def IfExp_del_body(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    IfExp_get_body(space, w_self)
+    w_self.deldictvalue(space, 'body')
+    w_self.initialization_state &= ~8
+
 def IfExp_get_orelse(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'orelse')
     w_self.deldictvalue(space, 'orelse')
     w_self.initialization_state |= 16
 
+def IfExp_del_orelse(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    IfExp_get_orelse(space, w_self)
+    w_self.deldictvalue(space, 'orelse')
+    w_self.initialization_state &= ~16
+
 _IfExp_field_unroller = unrolling_iterable(['test', 'body', 'orelse'])
 def IfExp_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(IfExp, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['test', 'body', 'orelse']),
-    test=typedef.GetSetProperty(IfExp_get_test, IfExp_set_test, cls=IfExp),
-    body=typedef.GetSetProperty(IfExp_get_body, IfExp_set_body, cls=IfExp),
-    orelse=typedef.GetSetProperty(IfExp_get_orelse, IfExp_set_orelse, cls=IfExp),
+    test=typedef.GetSetProperty(IfExp_get_test, IfExp_set_test, IfExp_del_test, cls=IfExp),
+    body=typedef.GetSetProperty(IfExp_get_body, IfExp_set_body, IfExp_del_body, cls=IfExp),
+    orelse=typedef.GetSetProperty(IfExp_get_orelse, IfExp_set_orelse, IfExp_del_orelse, cls=IfExp),
     __new__=interp2app(get_AST_new(IfExp)),
     __init__=interp2app(IfExp_init),
 )
     w_self.w_keys = w_new_value
     w_self.initialization_state |= 4
 
+def Dict_del_keys(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Dict_get_keys(space, w_self)
+    w_self.deldictvalue(space, 'keys')
+    w_self.initialization_state &= ~4
+
 def Dict_get_values(space, w_self):
     if not w_self.initialization_state & 8:
         raise_attriberr(space, w_self, 'values')
     w_self.w_values = w_new_value
     w_self.initialization_state |= 8
 
+def Dict_del_values(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Dict_get_values(space, w_self)
+    w_self.deldictvalue(space, 'values')
+    w_self.initialization_state &= ~8
+
 _Dict_field_unroller = unrolling_iterable(['keys', 'values'])
 def Dict_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Dict, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['keys', 'values']),
-    keys=typedef.GetSetProperty(Dict_get_keys, Dict_set_keys, cls=Dict),
-    values=typedef.GetSetProperty(Dict_get_values, Dict_set_values, cls=Dict),
+    keys=typedef.GetSetProperty(Dict_get_keys, Dict_set_keys, Dict_del_keys, cls=Dict),
+    values=typedef.GetSetProperty(Dict_get_values, Dict_set_values, Dict_del_values, cls=Dict),
     __new__=interp2app(get_AST_new(Dict)),
     __init__=interp2app(Dict_init),
 )
     w_self.w_elts = w_new_value
     w_self.initialization_state |= 4
 
+def Set_del_elts(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Set_get_elts(space, w_self)
+    w_self.deldictvalue(space, 'elts')
+    w_self.initialization_state &= ~4
+
 _Set_field_unroller = unrolling_iterable(['elts'])
 def Set_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Set, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['elts']),
-    elts=typedef.GetSetProperty(Set_get_elts, Set_set_elts, cls=Set),
+    elts=typedef.GetSetProperty(Set_get_elts, Set_set_elts, Set_del_elts, cls=Set),
     __new__=interp2app(get_AST_new(Set)),
     __init__=interp2app(Set_init),
 )
     w_self.deldictvalue(space, 'elt')
     w_self.initialization_state |= 4
 
+def ListComp_del_elt(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    ListComp_get_elt(space, w_self)
+    w_self.deldictvalue(space, 'elt')
+    w_self.initialization_state &= ~4
+
 def ListComp_get_generators(space, w_self):
     if not w_self.initialization_state & 8:
         raise_attriberr(space, w_self, 'generators')
     w_self.w_generators = w_new_value
     w_self.initialization_state |= 8
 
+def ListComp_del_generators(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    ListComp_get_generators(space, w_self)
+    w_self.deldictvalue(space, 'generators')
+    w_self.initialization_state &= ~8
+
 _ListComp_field_unroller = unrolling_iterable(['elt', 'generators'])
 def ListComp_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(ListComp, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['elt', 'generators']),
-    elt=typedef.GetSetProperty(ListComp_get_elt, ListComp_set_elt, cls=ListComp),
-    generators=typedef.GetSetProperty(ListComp_get_generators, ListComp_set_generators, cls=ListComp),
+    elt=typedef.GetSetProperty(ListComp_get_elt, ListComp_set_elt, ListComp_del_elt, cls=ListComp),
+    generators=typedef.GetSetProperty(ListComp_get_generators, ListComp_set_generators, ListComp_del_generators, cls=ListComp),
     __new__=interp2app(get_AST_new(ListComp)),
     __init__=interp2app(ListComp_init),
 )
     w_self.deldictvalue(space, 'elt')
     w_self.initialization_state |= 4
 
+def SetComp_del_elt(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    SetComp_get_elt(space, w_self)
+    w_self.deldictvalue(space, 'elt')
+    w_self.initialization_state &= ~4
+
 def SetComp_get_generators(space, w_self):
     if not w_self.initialization_state & 8:
         raise_attriberr(space, w_self, 'generators')
     w_self.w_generators = w_new_value
     w_self.initialization_state |= 8
 
+def SetComp_del_generators(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    SetComp_get_generators(space, w_self)
+    w_self.deldictvalue(space, 'generators')
+    w_self.initialization_state &= ~8
+
 _SetComp_field_unroller = unrolling_iterable(['elt', 'generators'])
 def SetComp_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(SetComp, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['elt', 'generators']),
-    elt=typedef.GetSetProperty(SetComp_get_elt, SetComp_set_elt, cls=SetComp),
-    generators=typedef.GetSetProperty(SetComp_get_generators, SetComp_set_generators, cls=SetComp),
+    elt=typedef.GetSetProperty(SetComp_get_elt, SetComp_set_elt, SetComp_del_elt, cls=SetComp),
+    generators=typedef.GetSetProperty(SetComp_get_generators, SetComp_set_generators, SetComp_del_generators, cls=SetComp),
     __new__=interp2app(get_AST_new(SetComp)),
     __init__=interp2app(SetComp_init),
 )
     w_self.deldictvalue(space, 'key')
     w_self.initialization_state |= 4
 
+def DictComp_del_key(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    DictComp_get_key(space, w_self)
+    w_self.deldictvalue(space, 'key')
+    w_self.initialization_state &= ~4
+
 def DictComp_get_value(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'value')
     w_self.deldictvalue(space, 'value')
     w_self.initialization_state |= 8
 
+def DictComp_del_value(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    DictComp_get_value(space, w_self)
+    w_self.deldictvalue(space, 'value')
+    w_self.initialization_state &= ~8
+
 def DictComp_get_generators(space, w_self):
     if not w_self.initialization_state & 16:
         raise_attriberr(space, w_self, 'generators')
     w_self.w_generators = w_new_value
     w_self.initialization_state |= 16
 
+def DictComp_del_generators(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    DictComp_get_generators(space, w_self)
+    w_self.deldictvalue(space, 'generators')
+    w_self.initialization_state &= ~16
+
 _DictComp_field_unroller = unrolling_iterable(['key', 'value', 'generators'])
 def DictComp_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(DictComp, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['key', 'value', 'generators']),
-    key=typedef.GetSetProperty(DictComp_get_key, DictComp_set_key, cls=DictComp),
-    value=typedef.GetSetProperty(DictComp_get_value, DictComp_set_value, cls=DictComp),
-    generators=typedef.GetSetProperty(DictComp_get_generators, DictComp_set_generators, cls=DictComp),
+    key=typedef.GetSetProperty(DictComp_get_key, DictComp_set_key, DictComp_del_key, cls=DictComp),
+    value=typedef.GetSetProperty(DictComp_get_value, DictComp_set_value, DictComp_del_value, cls=DictComp),
+    generators=typedef.GetSetProperty(DictComp_get_generators, DictComp_set_generators, DictComp_del_generators, cls=DictComp),
     __new__=interp2app(get_AST_new(DictComp)),
     __init__=interp2app(DictComp_init),
 )
     w_self.deldictvalue(space, 'elt')
     w_self.initialization_state |= 4
 
+def GeneratorExp_del_elt(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    GeneratorExp_get_elt(space, w_self)
+    w_self.deldictvalue(space, 'elt')
+    w_self.initialization_state &= ~4
+
 def GeneratorExp_get_generators(space, w_self):
     if not w_self.initialization_state & 8:
         raise_attriberr(space, w_self, 'generators')
     w_self.w_generators = w_new_value
     w_self.initialization_state |= 8
 
+def GeneratorExp_del_generators(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    GeneratorExp_get_generators(space, w_self)
+    w_self.deldictvalue(space, 'generators')
+    w_self.initialization_state &= ~8
+
 _GeneratorExp_field_unroller = unrolling_iterable(['elt', 'generators'])
 def GeneratorExp_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(GeneratorExp, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['elt', 'generators']),
-    elt=typedef.GetSetProperty(GeneratorExp_get_elt, GeneratorExp_set_elt, cls=GeneratorExp),
-    generators=typedef.GetSetProperty(GeneratorExp_get_generators, GeneratorExp_set_generators, cls=GeneratorExp),
+    elt=typedef.GetSetProperty(GeneratorExp_get_elt, GeneratorExp_set_elt, GeneratorExp_del_elt, cls=GeneratorExp),
+    generators=typedef.GetSetProperty(GeneratorExp_get_generators, GeneratorExp_set_generators, GeneratorExp_del_generators, cls=GeneratorExp),
     __new__=interp2app(get_AST_new(GeneratorExp)),
     __init__=interp2app(GeneratorExp_init),
 )
     w_self.deldictvalue(space, 'value')
     w_self.initialization_state |= 4
 
+def Yield_del_value(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Yield_get_value(space, w_self)
+    w_self.deldictvalue(space, 'value')
+    w_self.initialization_state &= ~4
+
 _Yield_field_unroller = unrolling_iterable(['value'])
 def Yield_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Yield, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['value']),
-    value=typedef.GetSetProperty(Yield_get_value, Yield_set_value, cls=Yield),
+    value=typedef.GetSetProperty(Yield_get_value, Yield_set_value, Yield_del_value, cls=Yield),
     __new__=interp2app(get_AST_new(Yield)),
     __init__=interp2app(Yield_init),
 )
     w_self.deldictvalue(space, 'left')
     w_self.initialization_state |= 4
 
+def Compare_del_left(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Compare_get_left(space, w_self)
+    w_self.deldictvalue(space, 'left')
+    w_self.initialization_state &= ~4
+
 def Compare_get_ops(space, w_self):
     if not w_self.initialization_state & 8:
         raise_attriberr(space, w_self, 'ops')
     w_self.w_ops = w_new_value
     w_self.initialization_state |= 8
 
+def Compare_del_ops(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Compare_get_ops(space, w_self)
+    w_self.deldictvalue(space, 'ops')
+    w_self.initialization_state &= ~8
+
 def Compare_get_comparators(space, w_self):
     if not w_self.initialization_state & 16:
         raise_attriberr(space, w_self, 'comparators')
     w_self.w_comparators = w_new_value
     w_self.initialization_state |= 16
 
+def Compare_del_comparators(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Compare_get_comparators(space, w_self)
+    w_self.deldictvalue(space, 'comparators')
+    w_self.initialization_state &= ~16
+
 _Compare_field_unroller = unrolling_iterable(['left', 'ops', 'comparators'])
 def Compare_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Compare, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['left', 'ops', 'comparators']),
-    left=typedef.GetSetProperty(Compare_get_left, Compare_set_left, cls=Compare),
-    ops=typedef.GetSetProperty(Compare_get_ops, Compare_set_ops, cls=Compare),
-    comparators=typedef.GetSetProperty(Compare_get_comparators, Compare_set_comparators, cls=Compare),
+    left=typedef.GetSetProperty(Compare_get_left, Compare_set_left, Compare_del_left, cls=Compare),
+    ops=typedef.GetSetProperty(Compare_get_ops, Compare_set_ops, Compare_del_ops, cls=Compare),
+    comparators=typedef.GetSetProperty(Compare_get_comparators, Compare_set_comparators, Compare_del_comparators, cls=Compare),
     __new__=interp2app(get_AST_new(Compare)),
     __init__=interp2app(Compare_init),
 )
     w_self.deldictvalue(space, 'func')
     w_self.initialization_state |= 4
 
+def Call_del_func(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Call_get_func(space, w_self)
+    w_self.deldictvalue(space, 'func')
+    w_self.initialization_state &= ~4
+
 def Call_get_args(space, w_self):
     if not w_self.initialization_state & 8:
         raise_attriberr(space, w_self, 'args')
     w_self.w_args = w_new_value
     w_self.initialization_state |= 8
 
+def Call_del_args(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Call_get_args(space, w_self)
+    w_self.deldictvalue(space, 'args')
+    w_self.initialization_state &= ~8
+
 def Call_get_keywords(space, w_self):
     if not w_self.initialization_state & 16:
         raise_attriberr(space, w_self, 'keywords')
     w_self.w_keywords = w_new_value
     w_self.initialization_state |= 16
 
+def Call_del_keywords(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Call_get_keywords(space, w_self)
+    w_self.deldictvalue(space, 'keywords')
+    w_self.initialization_state &= ~16
+
 def Call_get_starargs(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'starargs')
     w_self.deldictvalue(space, 'starargs')
     w_self.initialization_state |= 32
 
+def Call_del_starargs(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Call_get_starargs(space, w_self)
+    w_self.deldictvalue(space, 'starargs')
+    w_self.initialization_state &= ~32
+
 def Call_get_kwargs(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'kwargs')
     w_self.deldictvalue(space, 'kwargs')
     w_self.initialization_state |= 64
 
+def Call_del_kwargs(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Call_get_kwargs(space, w_self)
+    w_self.deldictvalue(space, 'kwargs')
+    w_self.initialization_state &= ~64
+
 _Call_field_unroller = unrolling_iterable(['func', 'args', 'keywords', 'starargs', 'kwargs'])
 def Call_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Call, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['func', 'args', 'keywords', 'starargs', 'kwargs']),
-    func=typedef.GetSetProperty(Call_get_func, Call_set_func, cls=Call),
-    args=typedef.GetSetProperty(Call_get_args, Call_set_args, cls=Call),
-    keywords=typedef.GetSetProperty(Call_get_keywords, Call_set_keywords, cls=Call),
-    starargs=typedef.GetSetProperty(Call_get_starargs, Call_set_starargs, cls=Call),
-    kwargs=typedef.GetSetProperty(Call_get_kwargs, Call_set_kwargs, cls=Call),
+    func=typedef.GetSetProperty(Call_get_func, Call_set_func, Call_del_func, cls=Call),
+    args=typedef.GetSetProperty(Call_get_args, Call_set_args, Call_del_args, cls=Call),
+    keywords=typedef.GetSetProperty(Call_get_keywords, Call_set_keywords, Call_del_keywords, cls=Call),
+    starargs=typedef.GetSetProperty(Call_get_starargs, Call_set_starargs, Call_del_starargs, cls=Call),
+    kwargs=typedef.GetSetProperty(Call_get_kwargs, Call_set_kwargs, Call_del_kwargs, cls=Call),
     __new__=interp2app(get_AST_new(Call)),
     __init__=interp2app(Call_init),
 )
     w_self.deldictvalue(space, 'value')
     w_self.initialization_state |= 4
 
+def Repr_del_value(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Repr_get_value(space, w_self)
+    w_self.deldictvalue(space, 'value')
+    w_self.initialization_state &= ~4
+
 _Repr_field_unroller = unrolling_iterable(['value'])
 def Repr_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Repr, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['value']),
-    value=typedef.GetSetProperty(Repr_get_value, Repr_set_value, cls=Repr),
+    value=typedef.GetSetProperty(Repr_get_value, Repr_set_value, Repr_del_value, cls=Repr),
     __new__=interp2app(get_AST_new(Repr)),
     __init__=interp2app(Repr_init),
 )
     w_self.deldictvalue(space, 'n')
     w_self.initialization_state |= 4
 
+def Num_del_n(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Num_get_n(space, w_self)
+    w_self.deldictvalue(space, 'n')
+    w_self.initialization_state &= ~4
+
 _Num_field_unroller = unrolling_iterable(['n'])
 def Num_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Num, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['n']),
-    n=typedef.GetSetProperty(Num_get_n, Num_set_n, cls=Num),
+    n=typedef.GetSetProperty(Num_get_n, Num_set_n, Num_del_n, cls=Num),
     __new__=interp2app(get_AST_new(Num)),
     __init__=interp2app(Num_init),
 )
     w_self.deldictvalue(space, 's')
     w_self.initialization_state |= 4
 
+def Str_del_s(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Str_get_s(space, w_self)
+    w_self.deldictvalue(space, 's')
+    w_self.initialization_state &= ~4
+
 _Str_field_unroller = unrolling_iterable(['s'])
 def Str_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Str, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['s']),
-    s=typedef.GetSetProperty(Str_get_s, Str_set_s, cls=Str),
+    s=typedef.GetSetProperty(Str_get_s, Str_set_s, Str_del_s, cls=Str),
     __new__=interp2app(get_AST_new(Str)),
     __init__=interp2app(Str_init),
 )
     w_self.deldictvalue(space, 'value')
     w_self.initialization_state |= 4
 
+def Attribute_del_value(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Attribute_get_value(space, w_self)
+    w_self.deldictvalue(space, 'value')
+    w_self.initialization_state &= ~4
+
 def Attribute_get_attr(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'attr')
     w_self.deldictvalue(space, 'attr')
     w_self.initialization_state |= 8
 
+def Attribute_del_attr(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Attribute_get_attr(space, w_self)
+    w_self.deldictvalue(space, 'attr')
+    w_self.initialization_state &= ~8
+
 def Attribute_get_ctx(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'ctx')
     w_self.setdictvalue(space, 'ctx', w_new_value)
     w_self.initialization_state |= 16
 
+def Attribute_del_ctx(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Attribute_get_ctx(space, w_self)
+    w_self.deldictvalue(space, 'ctx')
+    w_self.initialization_state &= ~16
+
 _Attribute_field_unroller = unrolling_iterable(['value', 'attr', 'ctx'])
 def Attribute_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Attribute, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['value', 'attr', 'ctx']),
-    value=typedef.GetSetProperty(Attribute_get_value, Attribute_set_value, cls=Attribute),
-    attr=typedef.GetSetProperty(Attribute_get_attr, Attribute_set_attr, cls=Attribute),
-    ctx=typedef.GetSetProperty(Attribute_get_ctx, Attribute_set_ctx, cls=Attribute),
+    value=typedef.GetSetProperty(Attribute_get_value, Attribute_set_value, Attribute_del_value, cls=Attribute),
+    attr=typedef.GetSetProperty(Attribute_get_attr, Attribute_set_attr, Attribute_del_attr, cls=Attribute),
+    ctx=typedef.GetSetProperty(Attribute_get_ctx, Attribute_set_ctx, Attribute_del_ctx, cls=Attribute),
     __new__=interp2app(get_AST_new(Attribute)),
     __init__=interp2app(Attribute_init),
 )
     w_self.deldictvalue(space, 'value')
     w_self.initialization_state |= 4
 
+def Subscript_del_value(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Subscript_get_value(space, w_self)
+    w_self.deldictvalue(space, 'value')
+    w_self.initialization_state &= ~4
+
 def Subscript_get_slice(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'slice')
     w_self.deldictvalue(space, 'slice')
     w_self.initialization_state |= 8
 
+def Subscript_del_slice(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Subscript_get_slice(space, w_self)
+    w_self.deldictvalue(space, 'slice')
+    w_self.initialization_state &= ~8
+
 def Subscript_get_ctx(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'ctx')
     w_self.setdictvalue(space, 'ctx', w_new_value)
     w_self.initialization_state |= 16
 
+def Subscript_del_ctx(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Subscript_get_ctx(space, w_self)
+    w_self.deldictvalue(space, 'ctx')
+    w_self.initialization_state &= ~16
+
 _Subscript_field_unroller = unrolling_iterable(['value', 'slice', 'ctx'])
 def Subscript_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Subscript, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['value', 'slice', 'ctx']),
-    value=typedef.GetSetProperty(Subscript_get_value, Subscript_set_value, cls=Subscript),
-    slice=typedef.GetSetProperty(Subscript_get_slice, Subscript_set_slice, cls=Subscript),
-    ctx=typedef.GetSetProperty(Subscript_get_ctx, Subscript_set_ctx, cls=Subscript),
+    value=typedef.GetSetProperty(Subscript_get_value, Subscript_set_value, Subscript_del_value, cls=Subscript),
+    slice=typedef.GetSetProperty(Subscript_get_slice, Subscript_set_slice, Subscript_del_slice, cls=Subscript),
+    ctx=typedef.GetSetProperty(Subscript_get_ctx, Subscript_set_ctx, Subscript_del_ctx, cls=Subscript),
     __new__=interp2app(get_AST_new(Subscript)),
     __init__=interp2app(Subscript_init),
 )
     w_self.deldictvalue(space, 'id')
     w_self.initialization_state |= 4
 
+def Name_del_id(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Name_get_id(space, w_self)
+    w_self.deldictvalue(space, 'id')
+    w_self.initialization_state &= ~4
+
 def Name_get_ctx(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'ctx')
     w_self.setdictvalue(space, 'ctx', w_new_value)
     w_self.initialization_state |= 8
 
+def Name_del_ctx(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Name_get_ctx(space, w_self)
+    w_self.deldictvalue(space, 'ctx')
+    w_self.initialization_state &= ~8
+
 _Name_field_unroller = unrolling_iterable(['id', 'ctx'])
 def Name_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Name, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['id', 'ctx']),
-    id=typedef.GetSetProperty(Name_get_id, Name_set_id, cls=Name),
-    ctx=typedef.GetSetProperty(Name_get_ctx, Name_set_ctx, cls=Name),
+    id=typedef.GetSetProperty(Name_get_id, Name_set_id, Name_del_id, cls=Name),
+    ctx=typedef.GetSetProperty(Name_get_ctx, Name_set_ctx, Name_del_ctx, cls=Name),
     __new__=interp2app(get_AST_new(Name)),
     __init__=interp2app(Name_init),
 )
     w_self.w_elts = w_new_value
     w_self.initialization_state |= 4
 
+def List_del_elts(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    List_get_elts(space, w_self)
+    w_self.deldictvalue(space, 'elts')
+    w_self.initialization_state &= ~4
+
 def List_get_ctx(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'ctx')
     w_self.setdictvalue(space, 'ctx', w_new_value)
     w_self.initialization_state |= 8
 
+def List_del_ctx(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    List_get_ctx(space, w_self)
+    w_self.deldictvalue(space, 'ctx')
+    w_self.initialization_state &= ~8
+
 _List_field_unroller = unrolling_iterable(['elts', 'ctx'])
 def List_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(List, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['elts', 'ctx']),
-    elts=typedef.GetSetProperty(List_get_elts, List_set_elts, cls=List),
-    ctx=typedef.GetSetProperty(List_get_ctx, List_set_ctx, cls=List),
+    elts=typedef.GetSetProperty(List_get_elts, List_set_elts, List_del_elts, cls=List),
+    ctx=typedef.GetSetProperty(List_get_ctx, List_set_ctx, List_del_ctx, cls=List),
     __new__=interp2app(get_AST_new(List)),
     __init__=interp2app(List_init),
 )
     w_self.w_elts = w_new_value
     w_self.initialization_state |= 4
 
+def Tuple_del_elts(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Tuple_get_elts(space, w_self)
+    w_self.deldictvalue(space, 'elts')
+    w_self.initialization_state &= ~4
+
 def Tuple_get_ctx(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'ctx')
     w_self.setdictvalue(space, 'ctx', w_new_value)
     w_self.initialization_state |= 8
 
+def Tuple_del_ctx(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Tuple_get_ctx(space, w_self)
+    w_self.deldictvalue(space, 'ctx')
+    w_self.initialization_state &= ~8
+
 _Tuple_field_unroller = unrolling_iterable(['elts', 'ctx'])
 def Tuple_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Tuple, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['elts', 'ctx']),
-    elts=typedef.GetSetProperty(Tuple_get_elts, Tuple_set_elts, cls=Tuple),
-    ctx=typedef.GetSetProperty(Tuple_get_ctx, Tuple_set_ctx, cls=Tuple),
+    elts=typedef.GetSetProperty(Tuple_get_elts, Tuple_set_elts, Tuple_del_elts, cls=Tuple),
+    ctx=typedef.GetSetProperty(Tuple_get_ctx, Tuple_set_ctx, Tuple_del_ctx, cls=Tuple),
     __new__=interp2app(get_AST_new(Tuple)),
     __init__=interp2app(Tuple_init),
 )
     w_self.deldictvalue(space, 'value')
     w_self.initialization_state |= 4
 
+def Const_del_value(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Const_get_value(space, w_self)
+    w_self.deldictvalue(space, 'value')
+    w_self.initialization_state &= ~4
+
 _Const_field_unroller = unrolling_iterable(['value'])
 def Const_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Const, w_self)
     expr.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['value']),
-    value=typedef.GetSetProperty(Const_get_value, Const_set_value, cls=Const),
+    value=typedef.GetSetProperty(Const_get_value, Const_set_value, Const_del_value, cls=Const),
     __new__=interp2app(get_AST_new(Const)),
     __init__=interp2app(Const_init),
 )
     w_self.deldictvalue(space, 'lower')
     w_self.initialization_state |= 1
 
+def Slice_del_lower(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Slice_get_lower(space, w_self)
+    w_self.deldictvalue(space, 'lower')
+    w_self.initialization_state &= ~1
+
 def Slice_get_upper(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'upper')
     w_self.deldictvalue(space, 'upper')
     w_self.initialization_state |= 2
 
+def Slice_del_upper(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Slice_get_upper(space, w_self)
+    w_self.deldictvalue(space, 'upper')
+    w_self.initialization_state &= ~2
+
 def Slice_get_step(space, w_self):
     if w_self.w_dict is not None:
         w_obj = w_self.getdictvalue(space, 'step')
     w_self.deldictvalue(space, 'step')
     w_self.initialization_state |= 4
 
+def Slice_del_step(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    Slice_get_step(space, w_self)
+    w_self.deldictvalue(space, 'step')
+    w_self.initialization_state &= ~4
+
 _Slice_field_unroller = unrolling_iterable(['lower', 'upper', 'step'])
 def Slice_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Slice, w_self)
     slice.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['lower', 'upper', 'step']),
-    lower=typedef.GetSetProperty(Slice_get_lower, Slice_set_lower, cls=Slice),
-    upper=typedef.GetSetProperty(Slice_get_upper, Slice_set_upper, cls=Slice),
-    step=typedef.GetSetProperty(Slice_get_step, Slice_set_step, cls=Slice),
+    lower=typedef.GetSetProperty(Slice_get_lower, Slice_set_lower, Slice_del_lower, cls=Slice),
+    upper=typedef.GetSetProperty(Slice_get_upper, Slice_set_upper, Slice_del_upper, cls=Slice),
+    step=typedef.GetSetProperty(Slice_get_step, Slice_set_step, Slice_del_step, cls=Slice),
     __new__=interp2app(get_AST_new(Slice)),
     __init__=interp2app(Slice_init),
 )
     w_self.w_dims = w_new_value
     w_self.initialization_state |= 1
 
+def ExtSlice_del_dims(space, w_self):
+    # Check if the element exists, raise appropriate exceptions
+    ExtSlice_get_dims(space, w_self)
+    w_self.deldictvalue(space, 'dims')
+    w_self.initialization_state &= ~1
+
 _ExtSlice_field_unroller = unrolling_iterable(['dims'])
 def ExtSlice_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(ExtSlice, w_self)
     slice.typedef,
     __module__='_ast',
     _fields=_FieldsWrapper(['dims']),
-    dims=typedef.GetSetProperty(ExtSlice_get_dims, ExtSlice_set_dims, cls=ExtSlice),
+    dims=typedef.GetSetProperty(ExtSlice_get_dims, ExtSlice_set_dims, ExtSlice_del_dims, cls=ExtSlice),
     __new__=interp2app(get_AST_new(ExtSlice)),
     __init__=interp2app(ExtSlice_init),
 )
     w_self.deldictvalue(space, 'value')