move _astng_fields to concrete classes instead of defining them in nodes.py

--HG--
branch : rebuild

1 files changed, 43 insertions, 1 deletions

diff --git a/node_classes.py b/node_classes.py
index 7310edb4..7c03cff2 100644
--- a/node_classes.py
+++ b/node_classes.py
@@ -251,6 +251,8 @@ class Name(LookupMixIn, NodeNG):
 
 class Arguments(NodeNG, AssignTypeMixin):
     """class representing an Arguments node"""
+    _astng_fields = ('args', 'defaults')
+
     def __init__(self, vararg=None, kwarg=None):
         self.vararg = vararg
         self.kwarg = kwarg
@@ -326,30 +328,37 @@ def _format_args(args, defaults=None):
 
 class AssAttr(NodeNG, ParentAssignTypeMixin):
     """class representing an AssAttr node"""
+    _astng_fields = ('expr',)
 
 
 class Assert(StmtMixIn, NodeNG):
     """class representing an Assert node"""
+    _astng_fields = ('test', 'fail',)
 
 
 class Assign(StmtMixIn, NodeNG, AssignTypeMixin):
     """class representing an Assign node"""
+    _astng_fields = ('targets', 'value',)
 
 
 class AugAssign(StmtMixIn, NodeNG, AssignTypeMixin):
     """class representing an AugAssign node"""
+    _astng_fields = ('target', 'value',)
 
 
 class Backquote(NodeNG):
     """class representing a Backquote node"""
+    _astng_fields = ('value',)
 
 
 class BinOp(NodeNG):
     """class representing a BinOp node"""
+    _astng_fields = ('left', 'right',)
 
 
 class BoolOp(NodeNG):
     """class representing a BoolOp node"""
+    _astng_fields = ('values',)
 
 
 class Break(StmtMixIn, NodeNG):
@@ -358,6 +367,7 @@ class Break(StmtMixIn, NodeNG):
 
 class CallFunc(NodeNG):
     """class representing a CallFunc node"""
+    _astng_fields = ('func', 'args', 'starargs', 'kwargs')
 
     def __init__(self):
         self.starargs = None
@@ -365,6 +375,7 @@ class CallFunc(NodeNG):
 
 class Compare(NodeNG):
     """class representing a Compare node"""
+    _astng_fields = ('left', 'ops',)
 
     def get_children(self):
         """override get_children for tuple fields"""
@@ -380,6 +391,7 @@ class Compare(NodeNG):
 
 class Comprehension(NodeNG):
     """class representing a Comprehension node"""
+    _astng_fields = ('target', 'iter' ,'ifs')
 
     def ass_type(self):
         return self
@@ -401,6 +413,7 @@ class Comprehension(NodeNG):
 
 class Const(NodeNG, Instance):
     """represent a Str or Num node"""
+
     def __init__(self, value=None):
         self.value = value
 
@@ -423,6 +436,8 @@ class Continue(StmtMixIn, NodeNG):
 
 class Decorators(NodeNG):
     """class representing a Decorators node"""
+    _astng_fields = ('nodes',)
+
     def __init__(self, nodes=None):
         self.nodes = nodes
 
@@ -432,14 +447,17 @@ class Decorators(NodeNG):
 
 class DelAttr(NodeNG, ParentAssignTypeMixin):
     """class representing a DelAttr node"""
+    _astng_fields = ('expr',)
 
 
 class Delete(StmtMixIn, NodeNG, AssignTypeMixin):
     """class representing a Delete node"""
+    _astng_fields = ('targets',)
 
 
 class Dict(NodeNG, Instance):
     """class representing a Dict node"""
+    _astng_fields = ('items',)
 
     def pytype(self):
         return '__builtin__.dict'
@@ -472,6 +490,7 @@ class Dict(NodeNG, Instance):
 
 class Discard(StmtMixIn, NodeNG):
     """class representing a Discard node"""
+    _astng_fields = ('value',)
 
 
 class Ellipsis(NodeNG):
@@ -484,6 +503,7 @@ class EmptyNode(NodeNG):
 
 class ExceptHandler(StmtMixIn, NodeNG, AssignTypeMixin):
     """class representing an ExceptHandler node"""
+    _astng_fields = ('type', 'name', 'body',)
 
     def _blockstart_toline(self):
         if self.name:
@@ -508,20 +528,22 @@ class ExceptHandler(StmtMixIn, NodeNG, AssignTypeMixin):
 
 class Exec(StmtMixIn, NodeNG):
     """class representing an Exec node"""
+    _astng_fields = ('expr', 'globals', 'locals',)
 
 
 class ExtSlice(NodeNG):
     """class representing an ExtSlice node"""
+    _astng_fields = ('dims',)
 
 
 class For(BlockRangeMixIn, StmtMixIn, AssignTypeMixin, NodeNG):
     """class representing a For node"""
+    _astng_fields = ('target', 'iter', 'body', 'orelse',)
 
     def _blockstart_toline(self):
         return self.iter.tolineno
 
 
-
 class From(FromImportMixIn, StmtMixIn, NodeNG):
     """class representing a From node"""
 
@@ -532,6 +554,7 @@ class From(FromImportMixIn, StmtMixIn, NodeNG):
 
 class Getattr(NodeNG):
     """class representing a Getattr node"""
+    _astng_fields = ('expr',)
 
 
 class Global(StmtMixIn, NodeNG):
@@ -546,6 +569,7 @@ class Global(StmtMixIn, NodeNG):
 
 class If(BlockRangeMixIn, StmtMixIn, NodeNG):
     """class representing an If node"""
+    _astng_fields = ('test', 'body', 'orelse')
 
     def _blockstart_toline(self):
         return self.test.tolineno
@@ -562,6 +586,7 @@ class If(BlockRangeMixIn, StmtMixIn, NodeNG):
 
 class IfExp(NodeNG):
     """class representing an IfExp node"""
+    _astng_fields = ('test', 'body', 'orelse')
 
 
 class Import(FromImportMixIn, StmtMixIn, NodeNG):
@@ -570,14 +595,17 @@ class Import(FromImportMixIn, StmtMixIn, NodeNG):
 
 class Index(NodeNG):
     """class representing an Index node"""
+    _astng_fields = ('value',)
 
 
 class Keyword(NodeNG):
     """class representing a Keyword node"""
+    _astng_fields = ('value',)
 
 
 class List(NodeNG, Instance, ParentAssignTypeMixin):
     """class representing a List node"""
+    _astng_fields = ('elts',) 
 
     def pytype(self):
         return '__builtin__.list'
@@ -592,6 +620,7 @@ class List(NodeNG, Instance, ParentAssignTypeMixin):
 
 class ListComp(NodeNG):
     """class representing a ListComp node"""
+    _astng_fields = ('elt', 'generators')
 
 
 class Pass(StmtMixIn, NodeNG):
@@ -600,26 +629,33 @@ class Pass(StmtMixIn, NodeNG):
 
 class Print(StmtMixIn, NodeNG):
     """class representing a Print node"""
+    _astng_fields = ('dest', 'values',)
 
 
 class Raise(StmtMixIn, NodeNG):
     """class representing a Raise node"""
+    _astng_fields = ('type', 'inst', 'tback')
 
 
 class Return(StmtMixIn, NodeNG):
     """class representing a Return node"""
+    _astng_fields = ('value',)
 
 
 class Slice(NodeNG):
     """class representing a Slice node"""
+    _astng_fields = ('lower', 'upper', 'step')
 
 
 class Subscript(NodeNG):
     """class representing a Subscript node"""
+    _astng_fields = ('value', 'slice')
 
 
 class TryExcept(BlockRangeMixIn, StmtMixIn, NodeNG):
     """class representing a TryExcept node"""
+    _astng_fields = ('body', 'handlers', 'orelse',)
+
     def _infer_name(self, frame, name):
         return name
 
@@ -641,6 +677,7 @@ class TryExcept(BlockRangeMixIn, StmtMixIn, NodeNG):
 
 class TryFinally(BlockRangeMixIn, StmtMixIn, NodeNG):
     """class representing a TryFinally node"""
+    _astng_fields = ('body', 'finalbody',)
 
     def _blockstart_toline(self):
         return self.lineno
@@ -657,6 +694,7 @@ class TryFinally(BlockRangeMixIn, StmtMixIn, NodeNG):
 
 class Tuple(NodeNG, Instance, ParentAssignTypeMixin):
     """class representing a Tuple node"""
+    _astng_fields = ('elts',)
 
     def pytype(self):
         return '__builtin__.tuple'
@@ -670,10 +708,12 @@ class Tuple(NodeNG, Instance, ParentAssignTypeMixin):
 
 class UnaryOp(NodeNG):
     """class representing an UnaryOp node"""
+    _astng_fields = ('operand',)
 
 
 class While(BlockRangeMixIn, StmtMixIn, NodeNG):
     """class representing a While node"""
+    _astng_fields = ('test', 'body', 'orelse',)
 
     def _blockstart_toline(self):
         return self.test.tolineno
@@ -684,6 +724,7 @@ class While(BlockRangeMixIn, StmtMixIn, NodeNG):
 
 class With(BlockRangeMixIn, StmtMixIn, AssignTypeMixin, NodeNG):
     """class representing a With node"""
+    _astng_fields = ('expr', 'vars', 'body')
 
     def _blockstart_toline(self):
         if self.vars:
@@ -694,6 +735,7 @@ class With(BlockRangeMixIn, StmtMixIn, AssignTypeMixin, NodeNG):
 
 class Yield(NodeNG):
     """class representing a Yield node"""
+    _astng_fields = ('value',)
 
 # constants ##############################################################