mojom: Remove braces from module statements and make them come first.

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
 
 def _GetDirAbove(dirname):
@@ skipping 17 matching lines @@
 
 class ParserTest(unittest.TestCase):
   """Tests |parser.Parse()|."""
 
   def testTrivialValidSource(self):
     """Tests a trivial, but valid, .mojom source."""
 
     source = """\
         // This is a comment.
 
-        module my_module {
-        }
+        module my_module;
         """
     expected = ast.Mojom(
         ast.Module(('IDENTIFIER', 'my_module'), None),
         ast.ImportList(),
         [])
     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"
+    source = "// This is a comment.\r\n\r\nmodule my_module;\r\n"
     expected = ast.Mojom(
         ast.Module(('IDENTIFIER', 'my_module'), None),
         ast.ImportList(),
         [])
     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 {
+        module my_module
         """
     with self.assertRaisesRegexp(
         parser.ParseError,
         r"^my_file\.mojom: Error: Unexpected end of file$"):
       parser.Parse(source, "my_file.mojom")
 
   def testCommentLineNumbers(self):
     """Tests that line numbers are correctly tracked when comments are
     present."""
 
     source1 = """\
         // Isolated C++-style comments.
 
         // Foo.
         asdf1
         """
     with self.assertRaisesRegexp(
         parser.ParseError,
         r"^my_file\.mojom:4: Error: Unexpected 'asdf1':\n *asdf1$"):
       parser.Parse(source1, "my_file.mojom")
 
     source2 = """\
         // Consecutive C++-style comments.
         // Foo.
-          // Bar.
+        // Bar.
 
         struct Yada {  // Baz.
-        // Quux.
+                       // Quux.
           int32 x;
         };
 
         asdf2
         """
     with self.assertRaisesRegexp(
         parser.ParseError,
         r"^my_file\.mojom:10: Error: Unexpected 'asdf2':\n *asdf2$"):
       parser.Parse(source2, "my_file.mojom")
 
@@ skipping 24 matching lines @@
     with self.assertRaisesRegexp(
         parser.ParseError,
         r"^my_file\.mojom:10: Error: Unexpected 'asdf4':\n *asdf4$"):
       parser.Parse(source4, "my_file.mojom")
 
 
   def testSimpleStruct(self):
     """Tests a simple .mojom source that just defines a struct."""
 
     source = """\
-        module my_module {
+        module my_module;
 
         struct MyStruct {
           int32 a;
           double b;
         };
-
-        }  // module my_module
         """
     expected = ast.Mojom(
         ast.Module(('IDENTIFIER', 'my_module'), None),
         ast.ImportList(),
         [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."""
+    """Tests a simple struct without an explict module statement."""
 
     source = """\
         struct MyStruct {
           int32 a;
           double b;
         };
         """
     expected = ast.Mojom(
         None,
         ast.ImportList(),
@@ skipping 69 matching lines @@
         parser.ParseError,
         r"^my_file\.mojom:2: Error: Unexpected 'interface':\n"
             r" *interface MyInterface {$"):
       parser.Parse(source3, "my_file.mojom")
 
   def testMissingModuleName(self):
     """Tests an (invalid) .mojom with a missing module name."""
 
     source1 = """\
         // Missing module name.
-        module {
+        module ;
         struct MyStruct {
           int32 a;
         };
-        }
         """
     with self.assertRaisesRegexp(
         parser.ParseError,
-        r"^my_file\.mojom:2: Error: Unexpected '{':\n *module {$"):
+        r"^my_file\.mojom:2: Error: Unexpected ';':\n *module ;$"):
       parser.Parse(source1, "my_file.mojom")
 
     # Another similar case, but make sure that line-number tracking/reporting
     # is correct.
     source2 = """\
         module
         // This line intentionally left unblank.
 
-        {
-        }
+        struct MyStruct {
+          int32 a;
+        };
         """
     with self.assertRaisesRegexp(
         parser.ParseError,
-        r"^my_file\.mojom:4: Error: Unexpected '{':\n *{$"):
+        r"^my_file\.mojom:4: Error: Unexpected 'struct':\n"
+            r" *struct MyStruct {$"):
       parser.Parse(source2, "my_file.mojom")
 
+  def testMultipleModuleStatements(self):
+    """Tests an (invalid) .mojom with multiple module statements."""
+
+    source = """\
+        module foo;
+        module bar;
+        """
+    with self.assertRaisesRegexp(
+        parser.ParseError,
+        r"^my_file\.mojom:2: Error: Multiple \"module\" statements not "
+            r"allowed:\n *module bar;$"):
+      parser.Parse(source, "my_file.mojom")
+
+  def testModuleStatementAfterImport(self):
+    """Tests an (invalid) .mojom with a module statement after an import."""
+
+    source = """\
+        import "foo.mojom";
+        module foo;
+        """
+    with self.assertRaisesRegexp(
+        parser.ParseError,
+        r"^my_file\.mojom:2: Error: \"module\" statements must precede imports "
+            r"and definitions:\n *module foo;$"):
+      parser.Parse(source, "my_file.mojom")
+
+  def testModuleStatementAfterDefinition(self):
+    """Tests an (invalid) .mojom with a module statement after a definition."""
+
+    source = """\
+        struct MyStruct {
+          int32 a;
+        };
+        module foo;
+        """
+    with self.assertRaisesRegexp(
+        parser.ParseError,
+        r"^my_file\.mojom:4: Error: \"module\" statements must precede imports "
+            r"and definitions:\n *module foo;$"):
+      parser.Parse(source, "my_file.mojom")
+
+  def testImportStatementAfterDefinition(self):
+    """Tests an (invalid) .mojom with an import statement after a definition."""
+
+    source = """\
+        struct MyStruct {
+          int32 a;
+        };
+        import "foo.mojom";
+        """
+    with self.assertRaisesRegexp(
+        parser.ParseError,
+        r"^my_file\.mojom:4: Error: \"import\" statements must precede "
+            r"definitions:\n *import \"foo.mojom\";$"):
+      parser.Parse(source, "my_file.mojom")
+
   def testEnums(self):
     """Tests that enum statements are correctly parsed."""
 
     source = """\
-        module my_module {
+        module my_module;
         enum MyEnum1 { VALUE1, VALUE2 };  // No trailing comma.
         enum MyEnum2 {
           VALUE1 = -1,
           VALUE2 = 0,
           VALUE3 = + 987,  // Check that space is allowed.
           VALUE4 = 0xAF12,
           VALUE5 = -0x09bcd,
           VALUE6 = VALUE5,
           VALUE7,  // Leave trailing comma.
         };
-        }  // my_module
         """
     expected = ast.Mojom(
         ast.Module(('IDENTIFIER', 'my_module'), None),
         ast.ImportList(),
         [ast.Enum(
             'MyEnum1',
             ast.EnumValueList([ast.EnumValue('VALUE1', None),
                                ast.EnumValue('VALUE2', None)])),
          ast.Enum(
             'MyEnum2',
@@ skipping 34 matching lines @@
     with self.assertRaisesRegexp(
         parser.ParseError,
         r"^my_file\.mojom:1: Error: Unexpected 'true':\n"
             r"enum MyEnum { VALUE = true };$"):
       parser.Parse(source2, "my_file.mojom")
 
   def testConsts(self):
     """Tests some constants and struct members initialized with them."""
 
     source = """\
-        module my_module {
+        module my_module;
 
         struct MyStruct {
           const int8 kNumber = -1;
           int8 number@0 = kNumber;
         };
-
-        }  // my_module
         """
     expected = ast.Mojom(
         ast.Module(('IDENTIFIER', 'my_module'), None),
         ast.ImportList(),
         [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 {
+        module my_module;
 
         enum MyEnum {
           MY_ENUM_1 = 1 ? 2 : 3
         };
-
-        }  // my_module
         """
     with self.assertRaisesRegexp(
         parser.ParseError,
         r"^my_file\.mojom:4: Error: Unexpected '\?':\n"
             r" *MY_ENUM_1 = 1 \? 2 : 3$"):
       parser.Parse(source, "my_file.mojom")
 
   def testSimpleOrdinals(self):
     """Tests that (valid) ordinal values are scanned correctly."""
 
     source = """\
-        module my_module {
+        module my_module;
 
         // This isn't actually valid .mojom, but the problem (missing ordinals)
         // should be handled at a different level.
         struct MyStruct {
           int32 a0@0;
           int32 a1@1;
           int32 a2@2;
           int32 a9@9;
           int32 a10 @10;
           int32 a11 @11;
           int32 a29 @29;
           int32 a1234567890 @1234567890;
         };
-
-        }  // module my_module
         """
     expected = ast.Mojom(
         ast.Module(('IDENTIFIER', 'my_module'), None),
         ast.ImportList(),
         [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 {
+        module my_module;
 
         struct MyStruct {
           int32 a_missing@;
         };
-
-        }  // module my_module
         """
     with self.assertRaisesRegexp(
         lexer.LexError,
         r"^my_file\.mojom:4: Error: Missing ordinal value$"):
       parser.Parse(source1, "my_file.mojom")
 
     source2 = """\
-        module my_module {
+        module my_module;
 
         struct MyStruct {
           int32 a_octal@01;
         };
-
-        }  // module my_module
         """
     with self.assertRaisesRegexp(
         lexer.LexError,
         r"^my_file\.mojom:4: Error: "
             r"Octal and hexadecimal ordinal values not allowed$"):
       parser.Parse(source2, "my_file.mojom")
 
     source3 = """\
-        module my_module { struct MyStruct { int32 a_invalid_octal@08; }; }
+        module my_module; struct MyStruct { int32 a_invalid_octal@08; };
         """
     with self.assertRaisesRegexp(
         lexer.LexError,
         r"^my_file\.mojom:1: Error: "
             r"Octal and hexadecimal ordinal values not allowed$"):
       parser.Parse(source3, "my_file.mojom")
 
-    source4 = "module my_module { struct MyStruct { int32 a_hex@0x1aB9; }; }"
+    source4 = "module my_module; struct MyStruct { int32 a_hex@0x1aB9; };"
     with self.assertRaisesRegexp(
         lexer.LexError,
         r"^my_file\.mojom:1: Error: "
             r"Octal and hexadecimal ordinal values not allowed$"):
       parser.Parse(source4, "my_file.mojom")
 
-    source5 = "module my_module { struct MyStruct { int32 a_hex@0X0; }; }"
+    source5 = "module my_module; struct MyStruct { int32 a_hex@0X0; };"
     with self.assertRaisesRegexp(
         lexer.LexError,
         r"^my_file\.mojom:1: Error: "
             r"Octal and hexadecimal ordinal values not allowed$"):
       parser.Parse(source5, "my_file.mojom")
 
     source6 = """\
         struct MyStruct {
           int32 a_too_big@999999999999;
         };
         """
     with self.assertRaisesRegexp(
         parser.ParseError,
         r"^my_file\.mojom:2: Error: "
             r"Ordinal value 999999999999 too large:\n"
             r" *int32 a_too_big@999999999999;$"):
       parser.Parse(source6, "my_file.mojom")
 
   def testNestedNamespace(self):
     """Tests that "nested" namespaces work."""
 
     source = """\
-        module my.mod {
+        module my.mod;
 
         struct MyStruct {
           int32 a;
         };
-
-        }  // module my.mod
         """
     expected = ast.Mojom(
         ast.Module(('IDENTIFIER', 'my.mod'), None),
         ast.ImportList(),
         [ast.Struct(
             'MyStruct',
             None,
             ast.StructBody(ast.StructField('a', None, 'int32', None)))])
     self.assertEquals(parser.Parse(source, "my_file.mojom"), expected)
 
@@ skipping 146 matching lines @@
   def testInvalidFixedArraySize(self):
     """Tests that invalid fixed array bounds are correctly detected."""
 
     source1 = """\
         struct MyStruct {
           array<int32, 0> zero_size_array;
         };
         """
     with self.assertRaisesRegexp(
         parser.ParseError,
-        r"^my_file\.mojom:2: Error: Fixed array size 0 invalid\n"
+        r"^my_file\.mojom:2: Error: Fixed array size 0 invalid:\n"
             r" *array<int32, 0> zero_size_array;$"):
       parser.Parse(source1, "my_file.mojom")
 
     source2 = """\
         struct MyStruct {
           array<int32, 999999999999> too_big_array;
         };
         """
     with self.assertRaisesRegexp(
         parser.ParseError,
-        r"^my_file\.mojom:2: Error: Fixed array size 999999999999 invalid\n"
+        r"^my_file\.mojom:2: Error: Fixed array size 999999999999 invalid:\n"
             r" *array<int32, 999999999999> too_big_array;$"):
       parser.Parse(source2, "my_file.mojom")
 
     source3 = """\
         struct MyStruct {
           array<int32, abcdefg> not_a_number;
         };
         """
     with self.assertRaisesRegexp(
         parser.ParseError,
@@ skipping 290 matching lines @@
         """
     expected2 = ast.Mojom(
         None,
         ast.ImportList([ast.Import("somedir/my1.mojom"),
                         ast.Import("somedir/my2.mojom")]),
         [])
     self.assertEquals(parser.Parse(source2, "my_file.mojom"), expected2)
 
     # Imports with module statement.
     source3 = """\
+        module my_module;
         import "somedir/my1.mojom";
         import "somedir/my2.mojom";
-        module my_module {}
         """
     expected3 = ast.Mojom(
         ast.Module(('IDENTIFIER', 'my_module'), None),
         ast.ImportList([ast.Import("somedir/my1.mojom"),
                         ast.Import("somedir/my2.mojom")]),
         [])
     self.assertEquals(parser.Parse(source3, "my_file.mojom"), expected3)
 
   def testInvalidImports(self):
     """Tests that invalid import statements are correctly detected."""
 
     source1 = """\
         // Make the error occur on line 2.
         import invalid
         """
     with self.assertRaisesRegexp(
         parser.ParseError,
         r"^my_file\.mojom:2: Error: Unexpected 'invalid':\n"
             r" *import invalid$"):
       parser.Parse(source1, "my_file.mojom")
 
     source2 = """\
         import  // Missing string.
-        module {}
+        struct MyStruct {
+          int32 a;
+        };
         """
     with self.assertRaisesRegexp(
         parser.ParseError,
-        r"^my_file\.mojom:2: Error: Unexpected 'module':\n"
-            r" *module {}$"):
+        r"^my_file\.mojom:2: Error: Unexpected 'struct':\n"
+            r" *struct MyStruct {$"):
       parser.Parse(source2, "my_file.mojom")
 
     source3 = """\
         import "foo.mojom"  // Missing semicolon.
-        module {}
+        struct MyStruct {
+          int32 a;
+        };
         """
     with self.assertRaisesRegexp(
         parser.ParseError,
-        r"^my_file\.mojom:2: Error: Unexpected 'module':\n"
-            r" *module {}$"):
+        r"^my_file\.mojom:2: Error: Unexpected 'struct':\n"
+            r" *struct MyStruct {$"):
       parser.Parse(source3, "my_file.mojom")
 
   def testValidNullableTypes(self):
     """Tests parsing nullable types."""
 
     source = """\
         struct MyStruct {
           int32? a;  // This is actually invalid, but handled at a different
                      // level.
           string? b;
@@ skipping 66 matching lines @@
         };
         """
     with self.assertRaisesRegexp(
         parser.ParseError,
         r"^my_file\.mojom:2: Error: Unexpected '&':\n"
             r" *some_interface\?& a;$"):
       parser.Parse(source3, "my_file.mojom")
 
 if __name__ == "__main__":
   unittest.main()