Fix bug with using enums as default values in mojom. We were previously

mojo/public/bindings/pylib/parse/mojo_parser.py

 #!/usr/bin/env python
 # Copyright 2013 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 sys
 import os.path
@@ skipping 225 matching lines @@
     """expression_array_elements : expression_object
                                  | expression_object COMMA expression_array_elements
                                  | """
     if len(p) == 2:
       p[0] = ListFromConcat(p[1])
     elif len(p) > 3:
       p[0] = ListFromConcat(p[1], p[3])
 
   def p_expression(self, p):
     """expression : conditional_expression"""
-    p[0] = p[1]
+    p[0] = ('EXPRESSION', p[1])
 
   def p_conditional_expression(self, p):
     """conditional_expression : binary_expression
                               | binary_expression CONDOP expression COLON \
                                     conditional_expression"""
     # Just pass the arguments through. I don't think it's possible to preserve
     # the spaces of the original, so just put a single space between them.
-    p[0] = ' '.join(p[1:])
+    p[0] = ListFromConcat(*p[1:])
 
   # PLY lets us specify precedence of operators, but since we don't actually
   # evaluate them, we don't need that here.
   def p_binary_expression(self, p):
     """binary_expression : unary_expression
                          | binary_expression binary_operator \
                                binary_expression"""
-    p[0] = ' '.join(p[1:])
+    p[0] = ListFromConcat(*p[1:])
 
   def p_binary_operator(self, p):
     """binary_operator : TIMES
                        | DIVIDE
                        | MOD
                        | PLUS
                        | MINUS
                        | RSHIFT
                        | LSHIFT
                        | LT
                        | LE
                        | GE
                        | GT
                        | EQ
                        | NE
                        | AND
                        | OR
                        | XOR
                        | LAND
                        | LOR"""
     p[0] = p[1]
 
   def p_unary_expression(self, p):
     """unary_expression : primary_expression
                         | unary_operator expression"""
-    p[0] = ''.join(p[1:])
+    p[0] = ListFromConcat(*p[1:])
 
   def p_unary_operator(self, p):
     """unary_operator : PLUS
                       | MINUS
                       | NOT
                       | LNOT"""
     p[0] = p[1]
 
   def p_primary_expression(self, p):
     """primary_expression : constant
-                          | NAME
-                          | NAME DOT NAME
+                          | identifier
                           | LPAREN expression RPAREN"""
+    p[0] = ListFromConcat(*p[1:])
+
+  def p_identifier(self, p):
+    """identifier : NAME
+                  | NAME DOT NAME"""
     p[0] = ''.join(p[1:])
 
   def p_constant(self, p):
     """constant : INT_CONST_DEC
                 | INT_CONST_OCT
                 | INT_CONST_HEX
                 | FLOAT_CONST
                 | HEX_FLOAT_CONST
                 | CHAR_CONST
                 | WCHAR_CONST
                 | STRING_LITERAL
                 | WSTRING_LITERAL"""
-    p[0] = ''.join(p[1:])
+    p[0] = ListFromConcat(*p[1:])
 
   def p_error(self, e):
     print('error: %s'%e)
 
 
 def Parse(filename):
   lexer = Lexer()
   parser = Parser(lexer)
 
   lex.lex(object=lexer)
   yacc.yacc(module=parser, debug=0, write_tables=0)
 
   tree = yacc.parse(open(filename).read())
   return tree
 
 
 def Main():
   if len(sys.argv) < 2:
     print("usage: %s filename" % (sys.argv[0]))
     sys.exit(1)
   tree = Parse(filename=sys.argv[1])
   print(tree)
 
 
 if __name__ == '__main__':
   Main()