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

mojo/public/tools/bindings/pylib/mojom_tests/parse/parser_unittest.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.
 
 import imp
 import os.path
 import sys
 import unittest
 
 # Disable lint check for finding modules:
@@ skipping 130 matching lines @@
         struct MyStruct {
           int32 a;
           double b;
         };
 
         }  // module my_module
         """
     expected = ast.Mojom(
         ast.Module(('IDENTIFIER', 'my_module'), None),
         ast.ImportList(),
-        [('STRUCT',
-          'MyStruct',
-          None,
-          [ast.StructField('a', None, 'int32', None),
-           ast.StructField('b', None, 'double', None)])])
+        [ast.Struct(
+            'MyStruct',
+            None,
+            ast.StructBody(
+                [ast.StructField('a', None, 'int32', None),
+                 ast.StructField('b', None, 'double', None)]))])
     self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
 
   def testSimpleStructWithoutModule(self):
     """Tests a simple struct without an enclosing module."""
 
     source = """\
         struct MyStruct {
           int32 a;
           double b;
         };
         """
     expected = ast.Mojom(
         None,
         ast.ImportList(),
-        [('STRUCT',
-          'MyStruct',
-          None,
-          [ast.StructField('a', None, 'int32', None),
-           ast.StructField('b', None, 'double', None)])])
+        [ast.Struct(
+            'MyStruct',
+            None,
+            ast.StructBody(
+                [ast.StructField('a', None, 'int32', None),
+                 ast.StructField('b', None, 'double', None)]))])
     self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
 
   def testMissingModuleName(self):
     """Tests an (invalid) .mojom with a missing module name."""
 
     source1 = """\
         // Missing module name.
         module {
         struct MyStruct {
           int32 a;
@@ skipping 94 matching lines @@
         struct MyStruct {
           const int8 kNumber = -1;
           int8 number@0 = kNumber;
         };
 
         }  // my_module
         """
     expected = ast.Mojom(
         ast.Module(('IDENTIFIER', 'my_module'), None),
         ast.ImportList(),
-        [('STRUCT',
-          'MyStruct', None,
-          [ast.Const('kNumber', 'int8', '-1'),
-           ast.StructField('number', ast.Ordinal(0), 'int8',
-                           ('IDENTIFIER', 'kNumber'))])])
+        [ast.Struct(
+            'MyStruct', None,
+            ast.StructBody(
+                [ast.Const('kNumber', 'int8', '-1'),
+                 ast.StructField('number', ast.Ordinal(0), 'int8',
+                                 ('IDENTIFIER', 'kNumber'))]))])
     self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
 
   def testNoConditionals(self):
     """Tests that ?: is not allowed."""
 
     source = """\
         module my_module {
 
         enum MyEnum {
           MY_ENUM_1 = 1 ? 2 : 3
@@ skipping 23 matching lines @@
           int32 a11 @11;
           int32 a29 @29;
           int32 a1234567890 @1234567890;
         };
 
         }  // module my_module
         """
     expected = ast.Mojom(
         ast.Module(('IDENTIFIER', 'my_module'), None),
         ast.ImportList(),
-        [('STRUCT',
-          'MyStruct',
-          None,
-          [ast.StructField('a0', ast.Ordinal(0), 'int32', None),
-           ast.StructField('a1', ast.Ordinal(1), 'int32', None),
-           ast.StructField('a2', ast.Ordinal(2), 'int32', None),
-           ast.StructField('a9', ast.Ordinal(9), 'int32', None),
-           ast.StructField('a10', ast.Ordinal(10), 'int32', None),
-           ast.StructField('a11', ast.Ordinal(11), 'int32', None),
-           ast.StructField('a29', ast.Ordinal(29), 'int32', None),
-           ast.StructField('a1234567890', ast.Ordinal(1234567890), 'int32',
-                           None)])])
+        [ast.Struct(
+            'MyStruct',
+            None,
+            ast.StructBody(
+                [ast.StructField('a0', ast.Ordinal(0), 'int32', None),
+                 ast.StructField('a1', ast.Ordinal(1), 'int32', None),
+                 ast.StructField('a2', ast.Ordinal(2), 'int32', None),
+                 ast.StructField('a9', ast.Ordinal(9), 'int32', None),
+                 ast.StructField('a10', ast.Ordinal(10), 'int32', None),
+                 ast.StructField('a11', ast.Ordinal(11), 'int32', None),
+                 ast.StructField('a29', ast.Ordinal(29), 'int32', None),
+                 ast.StructField('a1234567890', ast.Ordinal(1234567890),
+                                 'int32', None)]))])
     self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
 
   def testInvalidOrdinals(self):
     """Tests that (lexically) invalid ordinals are correctly detected."""
 
     source1 = """\
         module my_module {
 
         struct MyStruct {
           int32 a_missing@;
@@ skipping 64 matching lines @@
 
         struct MyStruct {
           int32 a;
         };
 
         }  // module my.mod
         """
     expected = ast.Mojom(
         ast.Module(('IDENTIFIER', 'my.mod'), None),
         ast.ImportList(),
-        [('STRUCT',
-          'MyStruct',
-          None,
-          [ast.StructField('a', None, 'int32', None)])])
+        [ast.Struct(
+            'MyStruct',
+            None,
+            ast.StructBody(ast.StructField('a', None, 'int32', None)))])
     self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
 
   def testValidHandleTypes(self):
     """Tests (valid) handle types."""
 
     source = """\
         struct MyStruct {
           handle a;
           handle<data_pipe_consumer> b;
           handle <data_pipe_producer> c;
           handle < message_pipe > d;
           handle
             < shared_buffer
             > e;
         };
         """
     expected = ast.Mojom(
         None,
         ast.ImportList(),
-        [('STRUCT',
-          'MyStruct',
-          None,
-          [ast.StructField('a', None, 'handle', None),
-           ast.StructField('b', None, 'handle<data_pipe_consumer>', None),
-           ast.StructField('c', None, 'handle<data_pipe_producer>', None),
-           ast.StructField('d', None, 'handle<message_pipe>', None),
-           ast.StructField('e', None, 'handle<shared_buffer>', None)])])
+        [ast.Struct(
+            'MyStruct',
+            None,
+            ast.StructBody(
+                [ast.StructField('a', None, 'handle', None),
+                 ast.StructField('b', None, 'handle<data_pipe_consumer>', None),
+                 ast.StructField('c', None, 'handle<data_pipe_producer>', None),
+                 ast.StructField('d', None, 'handle<message_pipe>', None),
+                 ast.StructField('e', None, 'handle<shared_buffer>', None)]))])
     self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
 
   def testInvalidHandleType(self):
     """Tests an invalid (unknown) handle type."""
 
     source = """\
         struct MyStruct {
           handle<wtf_is_this> foo;
         };
         """
@@ skipping 30 matching lines @@
           double a18 = 1.23E10;
           double a19 = 1.E-10;
           double a20 = .5E+10;
           double a21 = -1.23E10;
           double a22 = +.123E10;
         };
         """
     expected = ast.Mojom(
         None,
         ast.ImportList(),
-        [('STRUCT',
-          'MyStruct',
-          None,
-          [ast.StructField('a0', None, 'int16', '0'),
-           ast.StructField('a1', None, 'uint16', '0x0'),
-           ast.StructField('a2', None, 'uint16', '0x00'),
-           ast.StructField('a3', None, 'uint16', '0x01'),
-           ast.StructField('a4', None, 'uint16', '0xcd'),
-           ast.StructField('a5' , None, 'int32', '12345'),
-           ast.StructField('a6', None, 'int64', '-12345'),
-           ast.StructField('a7', None, 'int64', '+12345'),
-           ast.StructField('a8', None, 'uint32', '0x12cd3'),
-           ast.StructField('a9', None, 'uint32', '-0x12cD3'),
-           ast.StructField('a10', None, 'uint32', '+0x12CD3'),
-           ast.StructField('a11', None, 'bool', 'true'),
-           ast.StructField('a12', None, 'bool', 'false'),
-           ast.StructField('a13', None, 'float', '1.2345'),
-           ast.StructField('a14', None, 'float', '-1.2345'),
-           ast.StructField('a15', None, 'float', '+1.2345'),
-           ast.StructField('a16', None, 'float', '123.'),
-           ast.StructField('a17', None, 'float', '.123'),
-           ast.StructField('a18', None, 'double', '1.23E10'),
-           ast.StructField('a19', None, 'double', '1.E-10'),
-           ast.StructField('a20', None, 'double', '.5E+10'),
-           ast.StructField('a21', None, 'double', '-1.23E10'),
-           ast.StructField('a22', None, 'double', '+.123E10')])])
+        [ast.Struct(
+            'MyStruct',
+            None,
+            ast.StructBody(
+                [ast.StructField('a0', None, 'int16', '0'),
+                 ast.StructField('a1', None, 'uint16', '0x0'),
+                 ast.StructField('a2', None, 'uint16', '0x00'),
+                 ast.StructField('a3', None, 'uint16', '0x01'),
+                 ast.StructField('a4', None, 'uint16', '0xcd'),
+                 ast.StructField('a5' , None, 'int32', '12345'),
+                 ast.StructField('a6', None, 'int64', '-12345'),
+                 ast.StructField('a7', None, 'int64', '+12345'),
+                 ast.StructField('a8', None, 'uint32', '0x12cd3'),
+                 ast.StructField('a9', None, 'uint32', '-0x12cD3'),
+                 ast.StructField('a10', None, 'uint32', '+0x12CD3'),
+                 ast.StructField('a11', None, 'bool', 'true'),
+                 ast.StructField('a12', None, 'bool', 'false'),
+                 ast.StructField('a13', None, 'float', '1.2345'),
+                 ast.StructField('a14', None, 'float', '-1.2345'),
+                 ast.StructField('a15', None, 'float', '+1.2345'),
+                 ast.StructField('a16', None, 'float', '123.'),
+                 ast.StructField('a17', None, 'float', '.123'),
+                 ast.StructField('a18', None, 'double', '1.23E10'),
+                 ast.StructField('a19', None, 'double', '1.E-10'),
+                 ast.StructField('a20', None, 'double', '.5E+10'),
+                 ast.StructField('a21', None, 'double', '-1.23E10'),
+                 ast.StructField('a22', None, 'double', '+.123E10')]))])
     self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
 
   def testValidFixedSizeArray(self):
     """Tests parsing a fixed size array."""
 
     source = """\
         struct MyStruct {
           int32[] normal_array;
           int32[1] fixed_size_array_one_entry;
           int32[10] fixed_size_array_ten_entries;
         };
         """
     expected = ast.Mojom(
         None,
         ast.ImportList(),
-        [('STRUCT',
-          'MyStruct',
-          None,
-          [ast.StructField('normal_array', None, 'int32[]', None),
-           ast.StructField('fixed_size_array_one_entry', None, 'int32[1]',
-                           None),
-           ast.StructField('fixed_size_array_ten_entries', None, 'int32[10]',
-                           None)])])
+        [ast.Struct(
+            'MyStruct',
+            None,
+            ast.StructBody(
+                [ast.StructField('normal_array', None, 'int32[]', None),
+                 ast.StructField('fixed_size_array_one_entry', None, 'int32[1]',
+                                 None),
+                 ast.StructField('fixed_size_array_ten_entries', None,
+                                 'int32[10]', None)]))])
     self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
 
   def testValidNestedArray(self):
     """Tests parsing a nested array."""
 
     source = "struct MyStruct { int32[][] nested_array; };"
     expected = ast.Mojom(
         None,
         ast.ImportList(),
-        [('STRUCT',
-          'MyStruct',
-          None,
-          [ast.StructField('nested_array', None, 'int32[][]', None)])])
+        [ast.Struct(
+            'MyStruct',
+            None,
+            ast.StructBody(
+                ast.StructField('nested_array', None, 'int32[][]', None)))])
     self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
 
   def testInvalidFixedArraySize(self):
     """Tests that invalid fixed array bounds are correctly detected."""
 
     source1 = """\
         struct MyStruct {
           int32[0] zero_size_array;
         };
         """
@@ skipping 116 matching lines @@
   def testValidAttributes(self):
     """Tests parsing attributes (and attribute lists)."""
 
     # Note: We use structs because they have (optional) attribute lists.
 
     # Empty attribute list.
     source1 = "[] struct MyStruct {};"
     expected1 = ast.Mojom(
         None,
         ast.ImportList(),
-        [('STRUCT',
-          'MyStruct',
-          ast.AttributeList(),
-          None)])
+        [ast.Struct('MyStruct', ast.AttributeList(), ast.StructBody())])
     self.assertEquals(parser.Parse(source1, "my_file.mojom"), expected1)
 
     # One-element attribute list, with name value.
     source2 = "[MyAttribute=MyName] struct MyStruct {};"
     expected2 = ast.Mojom(
         None,
         ast.ImportList(),
-        [('STRUCT',
-          'MyStruct',
-          ast.AttributeList(ast.Attribute("MyAttribute", "MyName")),
-          None)])
+        [ast.Struct(
+            'MyStruct',
+            ast.AttributeList(ast.Attribute("MyAttribute", "MyName")),
+            ast.StructBody())])
     self.assertEquals(parser.Parse(source2, "my_file.mojom"), expected2)
 
     # Two-element attribute list, with one string value and one integer value.
     source3 = "[MyAttribute1 = \"hello\", MyAttribute2 = 5] struct MyStruct {};"
     expected3 = ast.Mojom(
         None,
         ast.ImportList(),
-        [('STRUCT',
-          'MyStruct',
-          ast.AttributeList([ast.Attribute("MyAttribute1", "hello"),
-                             ast.Attribute("MyAttribute2", 5)]),
-          None)])
+        [ast.Struct(
+            'MyStruct',
+            ast.AttributeList([ast.Attribute("MyAttribute1", "hello"),
+                               ast.Attribute("MyAttribute2", 5)]),
+            ast.StructBody())])
     self.assertEquals(parser.Parse(source3, "my_file.mojom"), expected3)
 
     # TODO(vtl): Boolean attributes don't work yet. (In fact, we just |eval()|
     # literal (non-name) values, which is extremely dubious.)
 
   def testInvalidAttributes(self):
     """Tests that invalid attributes and attribute lists are correctly
     detected."""
 
     # Trailing commas not allowed.
@@ skipping 74 matching lines @@
         """
     with self.assertRaisesRegexp(
         parser.ParseError,
         r"^my_file\.mojom:2: Error: Unexpected 'module':\n"
             r" *module {}$"):
       parser.Parse(source2, "my_file.mojom")
 
 
 if __name__ == "__main__":
   unittest.main()