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

mojo/public/tools/bindings/pylib/mojom/parse/parser.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.
 
 """Generates a syntax tree from a Mojo IDL file."""
 
 import imp
 import os.path
 import sys
 
@@ skipping 78 matching lines @@
   def p_root(self, p):
     """root : import root
             | module
             | definition_list"""
     if len(p) > 2:
       p[0] = _ListFromConcat(p[1], p[2])
     else:
       # Generator expects a module. If one wasn't specified insert one with an
       # empty name.
       if p[1][0] != 'MODULE':
-        p[0] = [('MODULE', '', None, p[1])]
+        p[0] = [('MODULE', None, None, p[1])]
       else:
         p[0] = [p[1]]
 
   def p_import(self, p):
     """import : IMPORT STRING_LITERAL"""
     # 'eval' the literal to strip the quotes.
     p[0] = ('IMPORT', eval(p[2]))
 
   def p_module(self, p):
-    """module : attribute_section MODULE identifier LBRACE definition_list \
-                    RBRACE"""
+    """module : attribute_section MODULE identifier_wrapped LBRACE \
+                    definition_list RBRACE"""
     p[0] = ('MODULE', p[3], p[1], p[5])
 
   def p_definition_list(self, p):
     """definition_list : definition definition_list
                        | """
     if len(p) > 1:
       p[0] = _ListFromConcat(p[1], p[2])
 
   def p_definition(self, p):
     """definition : struct
@@ skipping 187 matching lines @@
 
   def p_constant(self, p):
     """constant : literal
                 | identifier_wrapped"""
     p[0] = p[1]
 
   def p_identifier_wrapped(self, p):
     """identifier_wrapped : identifier"""
     p[0] = ('IDENTIFIER', p[1])
 
+  # TODO(vtl): Make this produce a "wrapped" identifier (probably as an
+  # |ast.Identifier|, to be added) and get rid of identifier_wrapped.
   def p_identifier(self, p):
     """identifier : NAME
                   | NAME DOT identifier"""
     p[0] = ''.join(p[1:])
 
   def p_literal(self, p):
     """literal : int
                | float
                | TRUE
                | FALSE
@@ skipping 33 matching lines @@
 
 def Parse(source, filename):
   lexer = Lexer(filename)
   parser = Parser(lexer, source, filename)
 
   lex.lex(object=lexer)
   yacc.yacc(module=parser, debug=0, write_tables=0)
 
   tree = yacc.parse(source)
   return tree