From ed259ec832456c791c82e5d9d52e7d845b32ed8b Mon Sep 17 00:00:00 2001
From: Nick Downing <nick@ndcode.org>
Date: Sun, 27 Jan 2019 22:29:58 +1100
Subject: [PATCH] Remove obsolete __repr__() and repr_serialize() on AST
 elements, change spacing

---
 ast.py          | 787 ++++++------------------------------------------
 generate_ast.py | 132 +++-----
 2 files changed, 127 insertions(+), 792 deletions(-)

diff --git a/ast.py b/ast.py
index 0616b8a..f7d4935 100644
--- a/ast.py
+++ b/ast.py
@@ -45,10 +45,6 @@ class AST(element.Element):
         Text if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Text({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class DeclarationOrStatement(element.Element):
@@ -73,10 +69,6 @@ class AST(element.Element):
         DeclarationOrStatement if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.DeclarationOrStatement({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_declaration_or_statement(self, context):
       #text = element.to_text(self).strip()
@@ -109,10 +101,6 @@ class AST(element.Element):
         Statement if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Statement({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class Declarator(element.Element):
@@ -137,10 +125,6 @@ class AST(element.Element):
         Declarator if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Declarator({0:s})'.format(', '.join(params))
     # GENERATE END
     def get_type_and_name(self, base_type):
       print(self)
@@ -168,10 +152,6 @@ class AST(element.Element):
         InitializerOrExpression if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.InitializerOrExpression({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_initializer_or_expression(self, context):
       print(self)
@@ -199,10 +179,6 @@ class AST(element.Element):
         Expression if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Expression({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_expression(self, context, precedence):
       #return element.to_text(self).strip()
@@ -235,8 +211,14 @@ class AST(element.Element):
       self.postfix = postfix
     def serialize(self, ref_list):
       AST.Expression.serialize(self, ref_list)
-      self.set('unary_operator', element.serialize_str(self.unary_operator))
-      self.set('postfix', element.serialize_bool(self.postfix))
+      self.set(
+        'unary_operator',
+        element.serialize_str(self.unary_operator)
+      )
+      self.set(
+        'postfix',
+        element.serialize_bool(self.postfix)
+      )
     def deserialize(self, ref_list):
       AST.Expression.deserialize(self, ref_list)
       self.unary_operator = element.deserialize_str(self.get('unary_operator', ''))
@@ -249,20 +231,6 @@ class AST(element.Element):
       result.unary_operator = self.unary_operator
       result.postfix = self.postfix
       return result
-    def repr_serialize(self, params):
-      AST.Expression.repr_serialize(self, params)
-      if self.unary_operator != '':
-        params.append(
-          'unary_operator = {0:s}'.format(repr(self.unary_operator))
-        )
-      if self.postfix != False:
-        params.append(
-          'postfix = {0:s}'.format(repr(self.postfix))
-        )
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionUnary({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_expression(self, context, precedence):
       if self.postfix:
@@ -305,9 +273,18 @@ class AST(element.Element):
       self.right_to_left = right_to_left
     def serialize(self, ref_list):
       AST.Expression.serialize(self, ref_list)
-      self.set('binary_operator', element.serialize_str(self.binary_operator))
-      self.set('precedence', element.serialize_int(self.precedence))
-      self.set('right_to_left', element.serialize_bool(self.right_to_left))
+      self.set(
+        'binary_operator',
+        element.serialize_str(self.binary_operator)
+      )
+      self.set(
+        'precedence',
+        element.serialize_int(self.precedence)
+      )
+      self.set(
+        'right_to_left',
+        element.serialize_bool(self.right_to_left)
+      )
     def deserialize(self, ref_list):
       AST.Expression.deserialize(self, ref_list)
       self.binary_operator = element.deserialize_str(self.get('binary_operator', ''))
@@ -322,24 +299,6 @@ class AST(element.Element):
       result.precedence = self.precedence
       result.right_to_left = self.right_to_left
       return result
-    def repr_serialize(self, params):
-      AST.Expression.repr_serialize(self, params)
-      if self.binary_operator != '':
-        params.append(
-          'binary_operator = {0:s}'.format(repr(self.binary_operator))
-        )
-      if self.precedence != -1:
-        params.append(
-          'precedence = {0:s}'.format(repr(self.precedence))
-        )
-      if self.right_to_left != False:
-        params.append(
-          'right_to_left = {0:s}'.format(repr(self.right_to_left))
-        )
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionBinary({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_expression(self, context, precedence):
       text = '{0:s}{1:s}{2:s}'.format(
@@ -380,10 +339,6 @@ class AST(element.Element):
         Type if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Type({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_size(self, context):
       print(self)
@@ -417,10 +372,6 @@ class AST(element.Element):
         TypeVoid if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TypeVoid({0:s})'.format(', '.join(params))
     # GENERATE END
     def __str__(self):
       return 'void'
@@ -453,8 +404,14 @@ class AST(element.Element):
       self.bits = bits
     def serialize(self, ref_list):
       AST.Type.serialize(self, ref_list)
-      self.set('signed', element.serialize_bool(self.signed))
-      self.set('bits', element.serialize_int(self.bits))
+      self.set(
+        'signed',
+        element.serialize_bool(self.signed)
+      )
+      self.set(
+        'bits',
+        element.serialize_int(self.bits)
+      )
     def deserialize(self, ref_list):
       AST.Type.deserialize(self, ref_list)
       self.signed = element.deserialize_bool(self.get('signed', 'false'))
@@ -467,20 +424,6 @@ class AST(element.Element):
       result.signed = self.signed
       result.bits = self.bits
       return result
-    def repr_serialize(self, params):
-      AST.Type.repr_serialize(self, params)
-      if self.signed != False:
-        params.append(
-          'signed = {0:s}'.format(repr(self.signed))
-        )
-      if self.bits != -1:
-        params.append(
-          'bits = {0:s}'.format(repr(self.bits))
-        )
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TypeInt({0:s})'.format(', '.join(params))
     # GENERATE END
     def __str__(self):
       return '{0:s}int{1:d}'.format(['u', ''][int(self.signed)], self.bits)
@@ -513,8 +456,14 @@ class AST(element.Element):
       self.bits = bits
     def serialize(self, ref_list):
       AST.Type.serialize(self, ref_list)
-      self.set('complex', element.serialize_int(self.complex))
-      self.set('bits', element.serialize_int(self.bits))
+      self.set(
+        'complex',
+        element.serialize_int(self.complex)
+      )
+      self.set(
+        'bits',
+        element.serialize_int(self.bits)
+      )
     def deserialize(self, ref_list):
       AST.Type.deserialize(self, ref_list)
       self.complex = element.deserialize_int(self.get('complex', '-1'))
@@ -527,20 +476,6 @@ class AST(element.Element):
       result.complex = self.complex
       result.bits = self.bits
       return result
-    def repr_serialize(self, params):
-      AST.Type.repr_serialize(self, params)
-      if self.complex != -1:
-        params.append(
-          'complex = {0:s}'.format(repr(self.complex))
-        )
-      if self.bits != -1:
-        params.append(
-          'bits = {0:s}'.format(repr(self.bits))
-        )
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TypeFloat({0:s})'.format(', '.join(params))
     # GENERATE END
     def __str__(self):
       return '{0:s}float{0:d}'.format(
@@ -576,10 +511,6 @@ class AST(element.Element):
         TypeBool if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TypeBool({0:s})'.format(', '.join(params))
     # GENERATE END
     def __str__(self):
       return 'bool'
@@ -610,7 +541,10 @@ class AST(element.Element):
       self.target_type = target_type
     def serialize(self, ref_list):
       AST.Type.serialize(self, ref_list)
-      self.set('target_type', element.serialize_ref(self.target_type, ref_list))
+      self.set(
+        'target_type',
+        element.serialize_ref(self.target_type, ref_list)
+      )
     def deserialize(self, ref_list):
       AST.Type.deserialize(self, ref_list)
       self.target_type = element.deserialize_ref(self.get('target_type', '-1'), ref_list)
@@ -621,16 +555,6 @@ class AST(element.Element):
       )
       result.target_type = self.target_type
       return result
-    def repr_serialize(self, params):
-      AST.Type.repr_serialize(self, params)
-      if self.target_type != None:
-        params.append(
-          'target_type = {0:s}'.format(repr(self.target_type))
-        )
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TypePointer({0:s})'.format(', '.join(params))
     # GENERATE END
     def __str__(self):
       return 'pointer<{0:s}>'.format(str(self.target_type))
@@ -681,8 +605,14 @@ class AST(element.Element):
       self.element_count = element_count
     def serialize(self, ref_list):
       AST.Type.serialize(self, ref_list)
-      self.set('element_type', element.serialize_ref(self.element_type, ref_list))
-      self.set('element_count', element.serialize_int(self.element_count))
+      self.set(
+        'element_type',
+        element.serialize_ref(self.element_type, ref_list)
+      )
+      self.set(
+        'element_count',
+        element.serialize_int(self.element_count)
+      )
     def deserialize(self, ref_list):
       AST.Type.deserialize(self, ref_list)
       self.element_type = element.deserialize_ref(self.get('element_type', '-1'), ref_list)
@@ -695,20 +625,6 @@ class AST(element.Element):
       result.element_type = self.element_type
       result.element_count = self.element_count
       return result
-    def repr_serialize(self, params):
-      AST.Type.repr_serialize(self, params)
-      if self.element_type != None:
-        params.append(
-          'element_type = {0:s}'.format(repr(self.element_type))
-        )
-      if self.element_count != -1:
-        params.append(
-          'element_count = {0:s}'.format(repr(self.element_count))
-        )
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TypeArray({0:s})'.format(', '.join(params))
     # GENERATE END
     def __str__(self):
       return 'array<{0:s}: {1:s}>'.format(
@@ -753,8 +669,14 @@ class AST(element.Element):
         self.name = name
       def serialize(self, ref_list):
         element.Element.serialize(self, ref_list)
-        self.set('type', element.serialize_ref(self.type, ref_list))
-        self.set('name', element.serialize_str(self.name))
+        self.set(
+          'type',
+          element.serialize_ref(self.type, ref_list)
+        )
+        self.set(
+          'name',
+          element.serialize_str(self.name)
+        )
       def deserialize(self, ref_list):
         element.Element.deserialize(self, ref_list)
         self.type = element.deserialize_ref(self.get('type', '-1'), ref_list)
@@ -767,20 +689,6 @@ class AST(element.Element):
         result.type = self.type
         result.name = self.name
         return result
-      def repr_serialize(self, params):
-        element.Element.repr_serialize(self, params)
-        if self.type != None:
-          params.append(
-            'type = {0:s}'.format(repr(self.type))
-          )
-        if self.name != '':
-          params.append(
-            'name = {0:s}'.format(repr(self.name))
-          )
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.TypeFunction.Argument({0:s})'.format(', '.join(params))
       # GENERATE END
       def __str__(self):
         return '{0:s} {1:s}'.format(
@@ -809,8 +717,14 @@ class AST(element.Element):
       self.varargs = varargs
     def serialize(self, ref_list):
       AST.Type.serialize(self, ref_list)
-      self.set('return_type', element.serialize_ref(self.return_type, ref_list))
-      self.set('varargs', element.serialize_bool(self.varargs))
+      self.set(
+        'return_type',
+        element.serialize_ref(self.return_type, ref_list)
+      )
+      self.set(
+        'varargs',
+        element.serialize_bool(self.varargs)
+      )
     def deserialize(self, ref_list):
       AST.Type.deserialize(self, ref_list)
       self.return_type = element.deserialize_ref(self.get('return_type', '-1'), ref_list)
@@ -823,20 +737,6 @@ class AST(element.Element):
       result.return_type = self.return_type
       result.varargs = self.varargs
       return result
-    def repr_serialize(self, params):
-      AST.Type.repr_serialize(self, params)
-      if self.return_type != None:
-        params.append(
-          'return_type = {0:s}'.format(repr(self.return_type))
-        )
-      if self.varargs != False:
-        params.append(
-          'varargs = {0:s}'.format(repr(self.varargs))
-        )
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TypeFunction({0:s})'.format(', '.join(params))
     # GENERATE END
     def __str__(self):
       return 'function<{0:s} -> {1:s}>'.format(
@@ -873,10 +773,6 @@ class AST(element.Element):
         AlignAsExpression if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.AlignAsExpression({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class AlignAsType(element.Element):
@@ -901,10 +797,6 @@ class AST(element.Element):
         AlignAsType if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.AlignAsType({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ArgumentExpressionList(element.Element):
@@ -929,10 +821,6 @@ class AST(element.Element):
         ArgumentExpressionList if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ArgumentExpressionList({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class BlockItemList(element.Element):
@@ -957,10 +845,6 @@ class AST(element.Element):
         BlockItemList if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.BlockItemList({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_block_item_list(self, context):
       for i in self:
@@ -988,10 +872,6 @@ class AST(element.Element):
         Declaration if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Declaration({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_declaration_or_statement(self, context):
       base_type = self[0].get_type()
@@ -1032,10 +912,6 @@ class AST(element.Element):
         DeclarationList if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.DeclarationList({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class DeclarationSpecifierList(element.Element):
@@ -1060,10 +936,6 @@ class AST(element.Element):
         DeclarationSpecifierList if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.DeclarationSpecifierList({0:s})'.format(', '.join(params))
     # GENERATE END
     def get_type(self):
       type_specifiers = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
@@ -1094,10 +966,6 @@ class AST(element.Element):
         DeclaratorAbstract if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.DeclaratorAbstract({0:s})'.format(', '.join(params))
     # GENERATE END
     def get_type_and_name(self, base_type):
       return base_type, ''
@@ -1124,10 +992,6 @@ class AST(element.Element):
         DeclaratorArray if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.DeclaratorArray({0:s})'.format(', '.join(params))
     # GENERATE END
     def get_type_and_name(self, base_type):
       return self[0].get_type_and_name(
@@ -1167,10 +1031,6 @@ class AST(element.Element):
         DeclaratorEmpty if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.DeclaratorEmpty({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class DeclaratorFunction(Declarator):
@@ -1193,7 +1053,10 @@ class AST(element.Element):
       self.varargs = varargs
     def serialize(self, ref_list):
       AST.Declarator.serialize(self, ref_list)
-      self.set('varargs', element.serialize_bool(self.varargs))
+      self.set(
+        'varargs',
+        element.serialize_bool(self.varargs)
+      )
     def deserialize(self, ref_list):
       AST.Declarator.deserialize(self, ref_list)
       self.varargs = element.deserialize_bool(self.get('varargs', 'false'))
@@ -1204,16 +1067,6 @@ class AST(element.Element):
       )
       result.varargs = self.varargs
       return result
-    def repr_serialize(self, params):
-      AST.Declarator.repr_serialize(self, params)
-      if self.varargs != False:
-        params.append(
-          'varargs = {0:s}'.format(repr(self.varargs))
-        )
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.DeclaratorFunction({0:s})'.format(', '.join(params))
     # GENERATE END
     def get_type_and_name(self, base_type):
       children = []
@@ -1250,10 +1103,6 @@ class AST(element.Element):
         DeclaratorFunctionOldStyle if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.DeclaratorFunctionOldStyle({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class DeclaratorIdentifier(Declarator):
@@ -1278,10 +1127,6 @@ class AST(element.Element):
         DeclaratorIdentifier if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.DeclaratorIdentifier({0:s})'.format(', '.join(params))
     # GENERATE END
     def get_type_and_name(self, base_type):
       return base_type, element.get_text(self[0], 0)
@@ -1308,10 +1153,6 @@ class AST(element.Element):
         DeclaratorPointer if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.DeclaratorPointer({0:s})'.format(', '.join(params))
     # GENERATE END
     def get_type_and_name(self, base_type):
       return self[1].get_type_and_name(
@@ -1340,10 +1181,6 @@ class AST(element.Element):
         DefaultTypeName if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.DefaultTypeName({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class DesignatorField(element.Element):
@@ -1368,10 +1205,6 @@ class AST(element.Element):
         DesignatorField if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.DesignatorField({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class DesignatorIndex(element.Element):
@@ -1396,10 +1229,6 @@ class AST(element.Element):
         DesignatorIndex if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.DesignatorIndex({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class DesignatorInitializer(InitializerOrExpression):
@@ -1424,10 +1253,6 @@ class AST(element.Element):
         DesignatorInitializer if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.DesignatorInitializer({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_initializer_or_expression(self, context):
       assert isinstance(self[0], AST.DesignatorListEqualsEmpty)
@@ -1455,10 +1280,6 @@ class AST(element.Element):
         DesignatorInitializerList if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.DesignatorInitializerList({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_initializer_or_expression(self, context):
       return '[{0:s}]'.format(
@@ -1492,10 +1313,6 @@ class AST(element.Element):
         DesignatorListEqualsEmpty if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.DesignatorListEqualsEmpty({0:s})'.format(', '.join(params))
     # GENERATE END
  
   class DesignatorList(element.Element):
@@ -1520,10 +1337,6 @@ class AST(element.Element):
         DesignatorList if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.DesignatorList({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class EnumSpecifier(element.Element):
@@ -1548,10 +1361,6 @@ class AST(element.Element):
         EnumSpecifier if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.EnumSpecifier({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class Enumerator(element.Element):
@@ -1576,10 +1385,6 @@ class AST(element.Element):
         Enumerator if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Enumerator({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class EnumeratorList(element.Element):
@@ -1604,10 +1409,6 @@ class AST(element.Element):
         EnumeratorList if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.EnumeratorList({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class EqualsInitializerEmpty(element.Element):
@@ -1632,10 +1433,6 @@ class AST(element.Element):
         EqualsInitializerEmpty if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.EqualsInitializerEmpty({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionAdd(ExpressionBinary):
@@ -1666,10 +1463,6 @@ class AST(element.Element):
         ExpressionAdd if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionAdd({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionAddAssignment(ExpressionBinary):
@@ -1700,10 +1493,6 @@ class AST(element.Element):
         ExpressionAddAssignment if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionAddAssignment({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionAddressOf(ExpressionUnary):
@@ -1732,10 +1521,6 @@ class AST(element.Element):
         ExpressionAddressOf if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionAddressOf({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionAlignOfType(ExpressionUnary):
@@ -1764,10 +1549,6 @@ class AST(element.Element):
         ExpressionAlignOfType if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionAlignOfType({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionArray(Expression):
@@ -1792,10 +1573,6 @@ class AST(element.Element):
         ExpressionArray if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionArray({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionAssignment(ExpressionBinary):
@@ -1826,10 +1603,6 @@ class AST(element.Element):
         ExpressionAssignment if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionAssignment({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionAsterisk(Expression):
@@ -1854,10 +1627,6 @@ class AST(element.Element):
         ExpressionAsterisk if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionAsterisk({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionBitwiseAnd(ExpressionBinary):
@@ -1888,10 +1657,6 @@ class AST(element.Element):
         ExpressionBitwiseAnd if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionBitwiseAnd({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionBitwiseAndAssignment(ExpressionBinary):
@@ -1922,10 +1687,6 @@ class AST(element.Element):
         ExpressionBitwiseAndAssignment if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionBitwiseAndAssignment({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionBitwiseNot(ExpressionUnary):
@@ -1954,10 +1715,6 @@ class AST(element.Element):
         ExpressionBitwiseNot if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionBitwiseNot({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionBitwiseOr(ExpressionBinary):
@@ -1988,10 +1745,6 @@ class AST(element.Element):
         ExpressionBitwiseOr if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionBitwiseOr({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionBitwiseOrAssignment(ExpressionBinary):
@@ -2022,10 +1775,6 @@ class AST(element.Element):
         ExpressionBitwiseOrAssignment if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionBitwiseOrAssignment({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionCall(Expression):
@@ -2050,10 +1799,6 @@ class AST(element.Element):
         ExpressionCall if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionCall({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_expression(self, context, precedence):
       text = '{0:s}({1:s})'.format(
@@ -2086,10 +1831,6 @@ class AST(element.Element):
         ExpressionCast if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionCast({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_expression(self, context, precedence):
       type, _ = self[0][1].get_type_and_name(self[0][0].get_type())
@@ -2123,10 +1864,6 @@ class AST(element.Element):
         ExpressionCharConstant if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionCharConstant({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_expression(self, context, precedence):
       return 'ord(\'{0:s}\')'.format(element.get_text(self[0], 0))
@@ -2159,10 +1896,6 @@ class AST(element.Element):
         ExpressionComma if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionComma({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionConditional(Expression):
@@ -2187,10 +1920,6 @@ class AST(element.Element):
         ExpressionConditional if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionConditional({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_expression(self, context, precedence):
       text = '{0:s} if {1:s} else {2:s}'.format(
@@ -2228,10 +1957,6 @@ class AST(element.Element):
         ExpressionDereference if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionDereference({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionDivide(ExpressionBinary):
@@ -2262,10 +1987,6 @@ class AST(element.Element):
         ExpressionDivide if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionDivide({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionDivideAssignment(ExpressionBinary):
@@ -2296,10 +2017,6 @@ class AST(element.Element):
         ExpressionDivideAssignment if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionDivideAssignment({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionEmpty(Expression):
@@ -2324,10 +2041,6 @@ class AST(element.Element):
         ExpressionEmpty if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionEmpty({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_expression(self, context, precedence):
       return 'True'
@@ -2362,10 +2075,6 @@ class AST(element.Element):
         ExpressionEqual if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionEqual({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionExclusiveOr(ExpressionBinary):
@@ -2396,10 +2105,6 @@ class AST(element.Element):
         ExpressionExclusiveOr if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionExclusiveOr({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionExclusiveOrAssignment(ExpressionBinary):
@@ -2430,10 +2135,6 @@ class AST(element.Element):
         ExpressionExclusiveOrAssignment if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionExclusiveOrAssignment({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionField(Expression):
@@ -2458,10 +2159,6 @@ class AST(element.Element):
         ExpressionField if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionField({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_expression(self, context, precedence):
       text = '{0:s}.{1:s}'.format(
@@ -2494,10 +2191,6 @@ class AST(element.Element):
         ExpressionFieldDereference if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionFieldDereference({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_expression(self, context, precedence):
       text = '{0:s}->{1:s}'.format(
@@ -2530,10 +2223,6 @@ class AST(element.Element):
         ExpressionFloatLiteral if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionFloatLiteral({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionFunctionName(Expression):
@@ -2558,10 +2247,6 @@ class AST(element.Element):
         ExpressionFunctionName if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionFunctionName({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionGreaterThan(ExpressionBinary):
@@ -2592,10 +2277,6 @@ class AST(element.Element):
         ExpressionGreaterThan if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionGreaterThan({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionGreaterThanOrEqual(ExpressionBinary):
@@ -2626,10 +2307,6 @@ class AST(element.Element):
         ExpressionGreaterThanOrEqual if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionGreaterThanOrEqual({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionIdentifier(Expression):
@@ -2654,10 +2331,6 @@ class AST(element.Element):
         ExpressionIdentifier if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionIdentifier({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_expression(self, context, precedence):
       return self[0].translate_identifier(context)
@@ -2684,10 +2357,6 @@ class AST(element.Element):
         ExpressionIndex if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionIndex({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_expression(self, context, precedence):
       text = '{0:s}[{1:s}]'.format(
@@ -2720,10 +2389,6 @@ class AST(element.Element):
         ExpressionIntLiteral if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionIntLiteral({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_expression(self, context, precedence):
       text = element.get_text(self, 0)
@@ -2759,10 +2424,6 @@ class AST(element.Element):
         ExpressionLeftShiftAssignment if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionLeftShiftAssignment({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionLessThan(ExpressionBinary):
@@ -2793,10 +2454,6 @@ class AST(element.Element):
         ExpressionLessThan if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionLessThan({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionLessThanOrEqual(ExpressionBinary):
@@ -2827,10 +2484,6 @@ class AST(element.Element):
         ExpressionLessThanOrEqual if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionLessThanOrEqual({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionLogicalAnd(ExpressionBinary):
@@ -2861,10 +2514,6 @@ class AST(element.Element):
         ExpressionLogicalAnd if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionLogicalAnd({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionLogicalNot(ExpressionUnary):
@@ -2893,10 +2542,6 @@ class AST(element.Element):
         ExpressionLogicalNot if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionLogicalNot({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionLogicalOr(ExpressionBinary):
@@ -2927,10 +2572,6 @@ class AST(element.Element):
         ExpressionLogicalOr if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionLogicalOr({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionMinus(ExpressionUnary):
@@ -2959,10 +2600,6 @@ class AST(element.Element):
         ExpressionMinus if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionMinus({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionModulo(ExpressionBinary):
@@ -2993,10 +2630,6 @@ class AST(element.Element):
         ExpressionModulo if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionModulo({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionModuloAssignment(ExpressionBinary):
@@ -3027,10 +2660,6 @@ class AST(element.Element):
         ExpressionModuloAssignment if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionModuloAssignment({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionMultiply(ExpressionBinary):
@@ -3061,10 +2690,6 @@ class AST(element.Element):
         ExpressionMultiply if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionMultiply({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionMultiplyAssignment(ExpressionBinary):
@@ -3095,10 +2720,6 @@ class AST(element.Element):
         ExpressionMultiplyAssignment if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionMultiplyAssignment({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionNotEqual(ExpressionBinary):
@@ -3129,10 +2750,6 @@ class AST(element.Element):
         ExpressionNotEqual if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionNotEqual({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionPlus(ExpressionUnary):
@@ -3161,10 +2778,6 @@ class AST(element.Element):
         ExpressionPlus if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionPlus({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionPostDecrement(ExpressionUnary):
@@ -3193,10 +2806,6 @@ class AST(element.Element):
         ExpressionPostDecrement if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionPostDecrement({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_statement_expression(self, context):
       return '{0:s} -= 1'.format(self[0].translate_expression(context, 0))
@@ -3227,10 +2836,6 @@ class AST(element.Element):
         ExpressionPostIncrement if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionPostIncrement({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_statement_expression(self, context):
       return '{0:s} += 1'.format(self[0].translate_expression(context, 0))
@@ -3261,10 +2866,6 @@ class AST(element.Element):
         ExpressionPreDecrement if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionPreDecrement({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_statement_expression(self, context):
       return '{0:s} -= 1'.format(self[0].translate_expression(context, 0))
@@ -3295,10 +2896,6 @@ class AST(element.Element):
         ExpressionPreIncrement if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionPreIncrement({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_statement_expression(self, context):
       return '{0:s} += 1'.format(self[0].translate_expression(context, 0))
@@ -3331,10 +2928,6 @@ class AST(element.Element):
         ExpressionRightShiftAssignment if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionRightShiftAssignment({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionShiftLeft(ExpressionBinary):
@@ -3365,10 +2958,6 @@ class AST(element.Element):
         ExpressionShiftLeft if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionShiftLeft({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionShiftRight(ExpressionBinary):
@@ -3399,10 +2988,6 @@ class AST(element.Element):
         ExpressionShiftRight if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionShiftRight({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionSizeOfExpression(ExpressionUnary):
@@ -3431,10 +3016,6 @@ class AST(element.Element):
         ExpressionSizeOfExpression if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionSizeOfExpression({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionSizeOfType(ExpressionUnary):
@@ -3463,10 +3044,6 @@ class AST(element.Element):
         ExpressionSizeOfType if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionSizeOfType({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_expression(self, context, precedence):
       type, _ = self[0][1].get_type_and_name(self[0][0].get_type())
@@ -3494,10 +3071,6 @@ class AST(element.Element):
         ExpressionStringLiteral if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionStringLiteral({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_expression(self, context, precedence):
       return ' '.join(
@@ -3539,10 +3112,6 @@ class AST(element.Element):
         ExpressionSubtract if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionSubtract({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ExpressionSubtractAssignment(ExpressionBinary):
@@ -3573,10 +3142,6 @@ class AST(element.Element):
         ExpressionSubtractAssignment if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ExpressionSubtractAssignment({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class FunctionDefinition(DeclarationOrStatement):
@@ -3601,10 +3166,6 @@ class AST(element.Element):
         FunctionDefinition if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.FunctionDefinition({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_declaration_or_statement(self, context):
       type, name = self[1].get_type_and_name(self[0].get_type())
@@ -3646,7 +3207,10 @@ class AST(element.Element):
       self.n = n
     def serialize(self, ref_list):
       element.Element.serialize(self, ref_list)
-      self.set('n', element.serialize_int(self.n))
+      self.set(
+        'n',
+        element.serialize_int(self.n)
+      )
     def deserialize(self, ref_list):
       element.Element.deserialize(self, ref_list)
       self.n = element.deserialize_int(self.get('n', '-1'))
@@ -3657,16 +3221,6 @@ class AST(element.Element):
       )
       result.n = self.n
       return result
-    def repr_serialize(self, params):
-      element.Element.repr_serialize(self, params)
-      if self.n != -1:
-        params.append(
-          'n = {0:s}'.format(repr(self.n))
-        )
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.FunctionSpecifier({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class GenericAssociation(element.Element):
@@ -3691,10 +3245,6 @@ class AST(element.Element):
         GenericAssociation if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.GenericAssociation({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class GenericAssociationList(element.Element):
@@ -3719,10 +3269,6 @@ class AST(element.Element):
         GenericAssociationList if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.GenericAssociationList({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class GenericSelection(element.Element):
@@ -3747,10 +3293,6 @@ class AST(element.Element):
         GenericSelection if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.GenericSelection({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class Identifier(element.Element):
@@ -3775,10 +3317,6 @@ class AST(element.Element):
         Identifier if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Identifier({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_identifier(self, context):
       text = element.get_text(self, 0)
@@ -3806,10 +3344,6 @@ class AST(element.Element):
         IdentifierEmpty if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.IdentifierEmpty({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class IdentifierList(element.Element):
@@ -3834,10 +3368,6 @@ class AST(element.Element):
         IdentifierList if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.IdentifierList({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class InitDeclarator(element.Element):
@@ -3862,10 +3392,6 @@ class AST(element.Element):
         InitDeclarator if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.InitDeclarator({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class InitDeclaratorList(element.Element):
@@ -3890,10 +3416,6 @@ class AST(element.Element):
         InitDeclaratorList if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.InitDeclaratorList({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ParameterDeclaration(element.Element):
@@ -3918,10 +3440,6 @@ class AST(element.Element):
         ParameterDeclaration if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ParameterDeclaration({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class ParameterDeclarationList(element.Element):
@@ -3946,10 +3464,6 @@ class AST(element.Element):
         ParameterDeclarationList if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ParameterDeclarationList({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class SpecifierQualifierList(element.Element):
@@ -3974,10 +3488,6 @@ class AST(element.Element):
         SpecifierQualifierList if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.SpecifierQualifierList({0:s})'.format(', '.join(params))
     # GENERATE END
     def get_type(self):
       type_specifiers = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
@@ -4008,10 +3518,6 @@ class AST(element.Element):
         StatementBlock if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StatementBlock({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_declaration_or_statement(self, context):
       if len(self[0]):
@@ -4041,10 +3547,6 @@ class AST(element.Element):
         StatementBreak if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StatementBreak({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_declaration_or_statement(self, context):
       context.lines.append('{0:s}break\n'.format(context.indent))
@@ -4071,10 +3573,6 @@ class AST(element.Element):
         StatementCase if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StatementCase({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class StatementContinue(Statement):
@@ -4099,10 +3597,6 @@ class AST(element.Element):
         StatementContinue if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StatementContinue({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_declaration_or_statement(self, context):
       enclosing_loop_save = context.enclosing_loop
@@ -4149,10 +3643,6 @@ class AST(element.Element):
         StatementDefault if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StatementDefault({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class StatementDoWhile(Statement):
@@ -4177,10 +3667,6 @@ class AST(element.Element):
         StatementDoWhile if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StatementDoWhile({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_declaration_or_statement(self, context):
       if (
@@ -4231,10 +3717,6 @@ class AST(element.Element):
         StatementExpression if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StatementExpression({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_declaration_or_statement(self, context):
       context.lines.append(
@@ -4266,10 +3748,6 @@ class AST(element.Element):
         StatementFor if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StatementFor({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_declaration_or_statement(self, context):
       self[0].translate_declaration_or_statement(context)
@@ -4315,10 +3793,6 @@ class AST(element.Element):
         StatementGoto if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StatementGoto({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class StatementIf(Statement):
@@ -4343,10 +3817,6 @@ class AST(element.Element):
         StatementIf if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StatementIf({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_declaration_or_statement(self, context):
       context.lines.append(
@@ -4382,10 +3852,6 @@ class AST(element.Element):
         StatementIfElse if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StatementIfElse({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_declaration_or_statement(self, context):
       context.lines.append(
@@ -4423,10 +3889,6 @@ class AST(element.Element):
         StatementLabel if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StatementLabel({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class StatementReturn(Statement):
@@ -4451,10 +3913,6 @@ class AST(element.Element):
         StatementReturn if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StatementReturn({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_declaration_or_statement(self, context):
       context.lines.append(
@@ -4486,10 +3944,6 @@ class AST(element.Element):
         StatementSwitch if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StatementSwitch({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_declaration_or_statement(self, context):
       assert isinstance(self[1], AST.StatementBlock)
@@ -4581,10 +4035,6 @@ class AST(element.Element):
         StatementWhile if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StatementWhile({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_declaration_or_statement(self, context):
       context.lines.append(
@@ -4623,10 +4073,6 @@ class AST(element.Element):
         StaticAssertDeclaration if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StaticAssertDeclaration({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_declaration_or_statement(self, context):
       pass
@@ -4651,7 +4097,10 @@ class AST(element.Element):
       self.n = n
     def serialize(self, ref_list):
       element.Element.serialize(self, ref_list)
-      self.set('n', element.serialize_int(self.n))
+      self.set(
+        'n',
+        element.serialize_int(self.n)
+      )
     def deserialize(self, ref_list):
       element.Element.deserialize(self, ref_list)
       self.n = element.deserialize_int(self.get('n', '-1'))
@@ -4662,16 +4111,6 @@ class AST(element.Element):
       )
       result.n = self.n
       return result
-    def repr_serialize(self, params):
-      element.Element.repr_serialize(self, params)
-      if self.n != -1:
-        params.append(
-          'n = {0:s}'.format(repr(self.n))
-        )
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StorageClassSpecifier({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class StructDeclaration(element.Element):
@@ -4696,10 +4135,6 @@ class AST(element.Element):
         StructDeclaration if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StructDeclaration({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class StructDeclarationList(element.Element):
@@ -4724,10 +4159,6 @@ class AST(element.Element):
         StructDeclarationList if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StructDeclarationList({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class StructDeclarator(element.Element):
@@ -4752,10 +4183,6 @@ class AST(element.Element):
         StructDeclarator if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StructDeclarator({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class StructDeclaratorList(element.Element):
@@ -4780,10 +4207,6 @@ class AST(element.Element):
         StructDeclaratorList if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StructDeclaratorList({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class StructSpecifier(element.Element):
@@ -4808,10 +4231,6 @@ class AST(element.Element):
         StructSpecifier if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.StructSpecifier({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class TypeName(element.Element):
@@ -4836,10 +4255,6 @@ class AST(element.Element):
         TypeName if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TypeName({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class TypeQualifier(element.Element):
@@ -4862,7 +4277,10 @@ class AST(element.Element):
       self.n = n
     def serialize(self, ref_list):
       element.Element.serialize(self, ref_list)
-      self.set('n', element.serialize_int(self.n))
+      self.set(
+        'n',
+        element.serialize_int(self.n)
+      )
     def deserialize(self, ref_list):
       element.Element.deserialize(self, ref_list)
       self.n = element.deserialize_int(self.get('n', '-1'))
@@ -4873,16 +4291,6 @@ class AST(element.Element):
       )
       result.n = self.n
       return result
-    def repr_serialize(self, params):
-      element.Element.repr_serialize(self, params)
-      if self.n != -1:
-        params.append(
-          'n = {0:s}'.format(repr(self.n))
-        )
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TypeQualifier({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class TypeQualifierList(element.Element):
@@ -4907,10 +4315,6 @@ class AST(element.Element):
         TypeQualifierList if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TypeQualifierList({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class TypeQualifierOrStaticList(element.Element):
@@ -4935,10 +4339,6 @@ class AST(element.Element):
         TypeQualifierOrStaticList if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TypeQualifierOrStaticList({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class TypeSpecifier(element.Element):
@@ -4961,7 +4361,10 @@ class AST(element.Element):
       self.n = n
     def serialize(self, ref_list):
       element.Element.serialize(self, ref_list)
-      self.set('n', element.serialize_int(self.n))
+      self.set(
+        'n',
+        element.serialize_int(self.n)
+      )
     def deserialize(self, ref_list):
       element.Element.deserialize(self, ref_list)
       self.n = element.deserialize_int(self.get('n', '-1'))
@@ -4972,16 +4375,6 @@ class AST(element.Element):
       )
       result.n = self.n
       return result
-    def repr_serialize(self, params):
-      element.Element.repr_serialize(self, params)
-      if self.n != -1:
-        params.append(
-          'n = {0:s}'.format(repr(self.n))
-        )
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TypeSpecifier({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class UnionSpecifier(element.Element):
@@ -5006,10 +4399,6 @@ class AST(element.Element):
         UnionSpecifier if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.UnionSpecifier({0:s})'.format(', '.join(params))
     # GENERATE END
 
   class TranslationUnit(element.Element):
@@ -5034,10 +4423,6 @@ class AST(element.Element):
         TranslationUnit if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TranslationUnit({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_translation_unit(self, context):
       for i in self:
@@ -5064,10 +4449,6 @@ class AST(element.Element):
       AST if factory is None else factory
     )
     return result
-  def __repr__(self):
-    params = []
-    self.repr_serialize(params)
-    return 'ast.AST({0:s})'.format(', '.join(params))
   # GENERATE END
 
 # void char short int long float double signed unsigned bool complex imaginary
diff --git a/generate_ast.py b/generate_ast.py
index 0e3155f..f65d4f3 100755
--- a/generate_ast.py
+++ b/generate_ast.py
@@ -163,7 +163,11 @@ while len(line):
         sys.stdout.write(
           '''{0:s}def serialize(self, ref_list):
 {1:s}  {2:s}.serialize(self, ref_list)
-'''.format(indent, indent, full_base_class)
+'''.format(
+            indent,
+            indent,
+            full_base_class
+          )
         )
         for type, name in fields:
           if type[:5] == 'list(' and type[-1:] == ')':
@@ -171,16 +175,26 @@ while len(line):
             sys.stdout.write(
               '''{0:s}  self.set(
 {1:s}    '{2:s}',
-{3:s}    ' '.join([element.serialize_{4:s}(i{5:s}) for i in self.{6:s}])
-{7:s}  )
+{3:s}    ' '.join(
+{4:s}      [
+{5:s}        element.serialize_{6:s}(i{7:s})
+{8:s}        for i in self.{9:s}
+{10:s}      ]
+{11:s}    )
+{12:s}  )
 '''.format(
                 indent,
                 indent,
                 name,
                 indent,
+                indent,
+                indent,
                 subtype,
                 ', ref_list' if subtype == 'ref' else '',
+                indent,
                 name,
+                indent,
+                indent,
                 indent
               )
             )
@@ -189,34 +203,54 @@ while len(line):
             sys.stdout.write(
               '''{0:s}  self.set(
 {1:s}    '{2:s}',
-{3:s}    ' '.join([element.serialize_{4:s}(i{5:s}) for i in sorted(self.{6:s})])
-{7:s}  )
+{3:s}    ' '.join(
+{4:s}      [
+{5:s}        element.serialize_{6:s}(i{7:s})
+{8:s}        for i in sorted(self.{9:s})
+{10:s}      ]
+{11:s}    )
+{12:s}  )
 '''.format(
                 indent,
                 indent,
                 name,
                 indent,
+                indent,
+                indent,
                 subtype,
                 ', ref_list' if subtype == 'ref' else '',
+                indent,
                 name,
+                indent,
+                indent,
                 indent
               )
             )
           else:
             sys.stdout.write(
-              '''{0:s}  self.set('{1:s}', element.serialize_{2:s}(self.{3:s}{4:s}))
+              '''{0:s}  self.set(
+{1:s}    '{2:s}',
+{3:s}    element.serialize_{4:s}(self.{5:s}{6:s})
+{7:s}  )
 '''.format(
+                indent,
                 indent,
                 name,
+                indent,
                 type,
                 name,
-                ', ref_list' if type == 'ref' else ''
+                ', ref_list' if type == 'ref' else '',
+                indent
               )
             )
         sys.stdout.write(
           '''{0:s}def deserialize(self, ref_list):
 {1:s}  {2:s}.deserialize(self, ref_list)
-'''.format(indent, indent, full_base_class)
+'''.format(
+            indent,
+            indent,
+            full_base_class
+          )
         )
         for type, name in fields:
           if type[:5] == 'list(' and type[-1:] == ')':
@@ -299,89 +333,9 @@ while len(line):
           indent
         )
       )
-      if len(fields):
-        sys.stdout.write(
-          '''{0:s}def repr_serialize(self, params):
-{1:s}  {2:s}.repr_serialize(self, params)
-'''.format(
-            indent,
-            indent,
-            full_base_class
-          )
-        )
-        for type, name in fields:
-          if type[:5] == 'list(' and type[-1:] == ')':
-            subtype = type[5:-1]
-            sys.stdout.write(
-              '''{0:s}  if len(self.{1:s}):
-{2:s}    params.append(
-{3:s}      '{4:s} = [{{0:s}}]'.format(
-{5:s}        ', '.join([repr(i) for i in self.{6:s}])
-{7:s}      )
-{8:s}    )
-'''.format(
-                indent,
-                name,
-                indent,
-                indent,
-                name,
-                indent,
-                name,
-                indent,
-                indent
-              )
-            )
-          elif type[:4] == 'set(' and type[-1:] == ')':
-            subtype = type[4:-1]
-            sys.stdout.write(
-              '''{0:s}  if len(self.{1:s}):
-{2:s}    params.append(
-{3:s}      '{4:s} = set([{{0:s}}])'.format(
-{5:s}        ', '.join([repr(i) for i in sorted(self.{6:s})])
-{7:s}      )
-{8:s}    )
-'''.format(
-                indent,
-                name,
-                indent,
-                indent,
-                name,
-                indent,
-                name,
-                indent,
-                indent
-              )
-            )
-          else:
-            sys.stdout.write(
-              '''{0:s}  if self.{1:s} != {2:s}:
-{3:s}    params.append(
-{4:s}      '{5:s} = {{0:s}}'.format(repr(self.{6:s}))
-{7:s}    )
-'''.format(
-                indent,
-                name,
-                default_value[type],
-                indent,
-                indent,
-                name,
-                name,
-                indent
-              )
-            )
       sys.stdout.write(
-        '''{0:s}def __repr__(self):
-{1:s}  params = []
-{2:s}  self.repr_serialize(params)
-{3:s}  return '{4:s}{5:s}({{0:s}})'.format(', '.join(params))
-{6:s}# GENERATE END
+        '''{0:s}# GENERATE END
 '''.format(
-          indent,
-          indent,
-          indent,
-          indent,
-          package_name,
-          '.'.join([i for _, i, _, _ in stack]),
           indent
         )
       )
-- 
2.34.1