Mojo: Mojom: Add AST types for struct and struct body.

mojo/public/tools/bindings/pylib/mojom/parse/translate.py

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Translates parse tree to Mojom IR."""
 
 
 import ast
 import re
 
@@ skipping 67 matching lines @@
             'kind': _MapKind(param.typename),
             'ordinal': param.ordinal.value if param.ordinal else None}
 
   method = {'name': tree[1],
             'parameters': map(ParameterToDict, tree[2]),
             'ordinal': tree[3].value if tree[3] else None}
   if tree[4]:
     method['response_parameters'] = map(ParameterToDict, tree[4])
   return method
 
-def _MapStruct(tree):
-  def StructFieldToDict(struct_field):
-    assert isinstance(struct_field, ast.StructField)
-    return {'name': struct_field.name,
-            'kind': _MapKind(struct_field.typename),
-            'ordinal': struct_field.ordinal.value \
-                if struct_field.ordinal else None,
-            'default': struct_field.default_value}
-
-  struct = {}
-  struct['name'] = tree[1]
-  struct['attributes'] = _AttributeListToDict(tree[2])
-  struct['fields'] = _MapTreeForType(StructFieldToDict, tree[3],
-                                     ast.StructField)
-  struct['enums'] = _MapTreeForType(_MapEnum, tree[3], ast.Enum)
-  struct['constants'] = _MapTreeForType(_MapConstant, tree[3], ast.Const)
-  return struct
-
 def _MapInterface(tree):
   interface = {}
   interface['name'] = tree[1]
   interface['attributes'] = _AttributeListToDict(tree[2])
   interface['client'] = interface['attributes'].get('Client')
   interface['methods'] = _MapTreeForName(_MapMethod, tree[3], 'METHOD')
   interface['enums'] = _MapTreeForType(_MapEnum, tree[3], ast.Enum)
   interface['constants'] = _MapTreeForType(_MapConstant, tree[3], ast.Const)
   return interface
 
@@ skipping 12 matching lines @@
   return {'name': const.name,
           'kind': _MapKind(const.typename),
           'value': const.value}
 
 
 class _MojomBuilder(object):
   def __init__(self):
     self.mojom = {}
 
   def Build(self, tree, name):
+    def StructToDict(struct):
+      def StructFieldToDict(struct_field):
+        assert isinstance(struct_field, ast.StructField)
+        return {'name': struct_field.name,
+                'kind': _MapKind(struct_field.typename),
+                'ordinal': struct_field.ordinal.value \
+                    if struct_field.ordinal else None,
+                'default': struct_field.default_value}
+
+      assert isinstance(struct, ast.Struct)
+      return {'name': struct.name,
+              'attributes': _AttributeListToDict(struct.attribute_list),
+              'fields': _MapTreeForType(StructFieldToDict, struct.body,
+                                        ast.StructField),
+              'enums': _MapTreeForType(_MapEnum, struct.body, ast.Enum),
+              'constants': _MapTreeForType(_MapConstant, struct.body,
+                                           ast.Const)}
+
     assert isinstance(tree, ast.Mojom)
     self.mojom['name'] = name
     self.mojom['namespace'] = tree.module.name[1] if tree.module else ''
     self.mojom['imports'] = \
         [{'filename': imp.import_filename} for imp in tree.import_list]
     self.mojom['attributes'] = \
         _AttributeListToDict(tree.module.attribute_list) if tree.module else {}
     self.mojom['structs'] = \
-        _MapTreeForName(_MapStruct, tree.definition_list, 'STRUCT')
+        _MapTreeForType(StructToDict, tree.definition_list, ast.Struct)
     self.mojom['interfaces'] = \
         _MapTreeForName(_MapInterface, tree.definition_list, 'INTERFACE')
     self.mojom['enums'] = \
         _MapTreeForType(_MapEnum, tree.definition_list, ast.Enum)
     self.mojom['constants'] = \
         _MapTreeForType(_MapConstant, tree.definition_list, ast.Const)
     return self.mojom
 
 
 def Translate(tree, name):
   return _MojomBuilder().Build(tree, name)