Mojo: Mojom parser: Make |module| use an |identifier_wrapped|.

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 23 matching lines @@
 
   def testTrivialValidSource(self):
     """Tests a trivial, but valid, .mojom source."""
 
     source = """\
         // This is a comment.
 
         module my_module {
         }
         """
-    self.assertEquals(parser.Parse(source, "my_file.mojom"),
-                      [("MODULE", "my_module", None, None)])
+    expected = [('MODULE', ('IDENTIFIER', 'my_module'), None, None)]
+    self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
 
   def testSourceWithCrLfs(self):
     """Tests a .mojom source with CR-LFs instead of LFs."""
 
     source = "// This is a comment.\r\n\r\nmodule my_module {\r\n}\r\n"
-    self.assertEquals(parser.Parse(source, "my_file.mojom"),
-                      [("MODULE", "my_module", None, None)])
+    expected = [('MODULE', ('IDENTIFIER', 'my_module'), None, None)]
+    self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
 
   def testUnexpectedEOF(self):
     """Tests a "truncated" .mojom source."""
 
     source = """\
         // This is a comment.
 
         module my_module {
         """
     with self.assertRaisesRegexp(
@@ skipping 71 matching lines @@
 
         struct MyStruct {
           int32 a;
           double b;
         };
 
         }  // module my_module
         """
     expected = \
         [('MODULE',
-          'my_module',
+          ('IDENTIFIER', 'my_module'),
           None,
           [('STRUCT',
             'MyStruct',
             None,
             [('FIELD', 'int32', 'a', ast.Ordinal(None), None),
              ('FIELD', 'double', 'b', ast.Ordinal(None), 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 = \
         [('MODULE',
-          '',
+          None,
           None,
           [('STRUCT',
             'MyStruct',
             None,
             [('FIELD', 'int32', 'a', ast.Ordinal(None), None),
              ('FIELD', 'double', 'b', ast.Ordinal(None), None)])])]
     self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
 
   def testMissingModuleName(self):
     """Tests an (invalid) .mojom with a missing module name."""
@@ skipping 37 matching lines @@
           VALUE3 = + 987,  // Check that space is allowed.
           VALUE4 = 0xAF12,
           VALUE5 = -0x09bcd,
           VALUE6 = VALUE5,
           VALUE7,  // Leave trailing comma.
         };
         }  // my_module
         """
     expected = \
         [('MODULE',
-          'my_module',
+          ('IDENTIFIER', 'my_module'),
           None,
           [('ENUM',
             'MyEnum1',
             [('ENUM_VALUE', 'VALUE1', None),
              ('ENUM_VALUE', 'VALUE2', None)]),
            ('ENUM',
             'MyEnum2',
             [('ENUM_VALUE', 'VALUE1', '-1'),
              ('ENUM_VALUE', 'VALUE2', '0'),
              ('ENUM_VALUE', 'VALUE3', '+987'),
@@ skipping 41 matching lines @@
 
         struct MyStruct {
           const int8 kNumber = -1;
           int8 number@0 = kNumber;
         };
 
         }  // my_module
         """
     expected = \
         [('MODULE',
-          'my_module',
+          ('IDENTIFIER', 'my_module'),
           None,
           [('STRUCT',
             'MyStruct', None,
             [('CONST', 'int8', 'kNumber', '-1'),
              ('FIELD', 'int8', 'number',
               ast.Ordinal(0), ('IDENTIFIER', 'kNumber'))])])]
     self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
 
   def testNoConditionals(self):
     """Tests that ?: is not allowed."""
@@ skipping 28 matching lines @@
           int32 a10 @10;
           int32 a11 @11;
           int32 a29 @29;
           int32 a1234567890 @1234567890;
         };
 
         }  // module my_module
         """
     expected = \
         [('MODULE',
-          'my_module',
+          ('IDENTIFIER', 'my_module'),
           None,
           [('STRUCT',
             'MyStruct',
             None,
             [('FIELD', 'int32', 'a0', ast.Ordinal(0), None),
              ('FIELD', 'int32', 'a1', ast.Ordinal(1), None),
              ('FIELD', 'int32', 'a2', ast.Ordinal(2), None),
              ('FIELD', 'int32', 'a9', ast.Ordinal(9), None),
              ('FIELD', 'int32', 'a10', ast.Ordinal(10), None),
              ('FIELD', 'int32', 'a11', ast.Ordinal(11), None),
@@ skipping 76 matching lines @@
         module my.mod {
 
         struct MyStruct {
           int32 a;
         };
 
         }  // module my.mod
         """
     expected = \
         [('MODULE',
-          'my.mod',
+          ('IDENTIFIER', 'my.mod'),
           None,
           [('STRUCT',
             'MyStruct',
             None,
             [('FIELD', 'int32', 'a', ast.Ordinal(None), 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 = \
         [('MODULE',
-          '',
+          None,
           None,
           [('STRUCT',
             'MyStruct',
             None,
             [('FIELD', 'handle', 'a', ast.Ordinal(None), None),
              ('FIELD', 'handle<data_pipe_consumer>', 'b', ast.Ordinal(None),
               None),
              ('FIELD', 'handle<data_pipe_producer>', 'c', ast.Ordinal(None),
               None),
              ('FIELD', 'handle<message_pipe>', 'd', ast.Ordinal(None), None),
@@ skipping 41 matching lines @@
           float a17 = .123;
           double a18 = 1.23E10;
           double a19 = 1.E-10;
           double a20 = .5E+10;
           double a21 = -1.23E10;
           double a22 = +.123E10;
         };
         """
     expected = \
         [('MODULE',
-          '',
+          None,
           None,
           [('STRUCT',
             'MyStruct',
             None,
             [('FIELD', 'int16', 'a0', ast.Ordinal(None), '0'),
              ('FIELD', 'uint16', 'a1', ast.Ordinal(None), '0x0'),
              ('FIELD', 'uint16', 'a2', ast.Ordinal(None), '0x00'),
              ('FIELD', 'uint16', 'a3', ast.Ordinal(None), '0x01'),
              ('FIELD', 'uint16', 'a4', ast.Ordinal(None), '0xcd'),
              ('FIELD', 'int32', 'a5' , ast.Ordinal(None), '12345'),
@@ skipping 21 matching lines @@
 
     source = """\
         struct MyStruct {
           int32[] normal_array;
           int32[1] fixed_size_array_one_entry;
           int32[10] fixed_size_array_ten_entries;
         };
         """
     expected = \
         [('MODULE',
-          '',
+          None,
           None,
           [('STRUCT',
             'MyStruct',
             None,
             [('FIELD', 'int32[]', 'normal_array', ast.Ordinal(None), None),
              ('FIELD', 'int32[1]', 'fixed_size_array_one_entry',
               ast.Ordinal(None), None),
              ('FIELD', 'int32[10]', 'fixed_size_array_ten_entries',
               ast.Ordinal(None), 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 = \
         [('MODULE',
-          '',
+          None,
           None,
           [('STRUCT',
             'MyStruct',
             None,
             [('FIELD', 'int32[][]', 'nested_array', ast.Ordinal(None),
               None)])])]
     self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
 
   def testInvalidFixedArraySize(self):
     """Tests that invalid fixed array bounds are correctly detected."""
@@ skipping 30 matching lines @@
         r"^my_file\.mojom:2: Error: Unexpected 'abcdefg':\n"
         r" *int32\[abcdefg\] not_a_number;"):
       parser.Parse(source3, "my_file.mojom")
 
   def testValidMethod(self):
     """Tests parsing method declarations."""
 
     source1 = "interface MyInterface { MyMethod(int32 a); };"
     expected1 = \
         [('MODULE',
-          '',
+          None,
           None,
           [('INTERFACE',
             'MyInterface',
             None,
             [('METHOD',
               'MyMethod',
               ast.ParameterList(ast.Parameter('int32', 'a', ast.Ordinal(None))),
               ast.Ordinal(None),
               None)])])]
     self.assertEquals(parser.Parse(source1, "my_file.mojom"), expected1)
 
     source2 = """\
         interface MyInterface {
           MyMethod1@0(int32 a@0, int64 b@1);
           MyMethod2@1() => ();
         };
         """
     expected2 = \
         [('MODULE',
-          '',
+          None,
           None,
           [('INTERFACE',
             'MyInterface',
             None,
             [('METHOD',
               'MyMethod1',
               ast.ParameterList([ast.Parameter('int32', 'a', ast.Ordinal(0)),
                                  ast.Parameter('int64', 'b', ast.Ordinal(1))]),
               ast.Ordinal(0),
               None),
              ('METHOD',
               'MyMethod2',
               ast.ParameterList(),
               ast.Ordinal(1),
               ast.ParameterList())])])]
     self.assertEquals(parser.Parse(source2, "my_file.mojom"), expected2)
 
     source3 = """\
         interface MyInterface {
           MyMethod(string a) => (int32 a, bool b);
         };
         """
     expected3 = \
         [('MODULE',
-          '',
+          None,
           None,
           [('INTERFACE',
             'MyInterface',
             None,
             [('METHOD',
               'MyMethod',
               ast.ParameterList(ast.Parameter('string', 'a',
                                               ast.Ordinal(None))),
               ast.Ordinal(None),
               ast.ParameterList([ast.Parameter('int32', 'a', ast.Ordinal(None)),
@@ skipping 30 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 = \
         [('MODULE',
-          '',
+          None,
           None,
           [('STRUCT',
             'MyStruct',
             ast.AttributeList(),
             None)])]
     self.assertEquals(parser.Parse(source1, "my_file.mojom"), expected1)
 
     # One-element attribute list, with name value.
     source2 = "[MyAttribute=MyName] struct MyStruct {};"
     expected2 = \
         [('MODULE',
-          '',
+          None,
           None,
           [('STRUCT',
             'MyStruct',
             ast.AttributeList(ast.Attribute("MyAttribute", "MyName")),
             None)])]
     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 = \
         [('MODULE',
-          '',
+          None,
           None,
           [('STRUCT',
             'MyStruct',
             ast.AttributeList([ast.Attribute("MyAttribute1", "hello"),
                                ast.Attribute("MyAttribute2", 5)]),
             None)])]
     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.)
@@ skipping 21 matching lines @@
     # Missing key.
     source3 = "[=MyName] struct MyStruct {};"
     with self.assertRaisesRegexp(
         parser.ParseError,
         r"^my_file\.mojom:1: Error: Unexpected '=':\n"
             r"\[=MyName\] struct MyStruct {};$"):
       parser.Parse(source3, "my_file.mojom")
 
 if __name__ == "__main__":
   unittest.main()