Mojo: Mojom: Remove default values for structs and arrays.

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 125 matching lines @@
                    | """
     if len(p) > 1:
       p[0] = _ListFromConcat(p[1], p[2])
 
   def p_field(self, p):
     """field : typename NAME default ordinal SEMI"""
     p[0] = ('FIELD', p[1], p[2], p[4], p[3])
 
   def p_default(self, p):
     """default : EQUALS expression
-               | EQUALS expression_object
                | """
     if len(p) > 2:
       p[0] = p[2]
 
   def p_interface(self, p):
     """interface : attribute_section INTERFACE NAME LBRACE interface_body \
                        RBRACE SEMI"""
     p[0] = ('INTERFACE', p[3], p[1], p[5])
 
   def p_interface_body(self, p):
@@ skipping 93 matching lines @@
       p[0] = ('ENUM_FIELD', p[1], None)
     else:
       p[0] = ('ENUM_FIELD', p[1], p[3])
 
   def p_const(self, p):
     """const : CONST typename NAME EQUALS expression SEMI"""
     p[0] = ('CONST', p[2], p[3], p[5])
 
   ### Expressions ###
 
-  def p_expression_object(self, p):
-    """expression_object : expression_array
-                         | LBRACE expression_object_elements RBRACE """
-    if len(p) < 3:
-      p[0] = p[1]
-    else:
-      p[0] = ('OBJECT', p[2])
-
-  def p_expression_object_elements(self, p):
-    """expression_object_elements : expression_object
-                                  | expression_object COMMA expression_object_elements
-                                  | """
-    if len(p) == 2:
-      p[0] = _ListFromConcat(p[1])
-    elif len(p) > 3:
-      p[0] = _ListFromConcat(p[1], p[3])
-
-  def p_expression_array(self, p):
-    """expression_array : expression
-                        | LBRACKET expression_array_elements RBRACKET """
-    if len(p) < 3:
-      p[0] = p[1]
-    else:
-      p[0] = ('ARRAY', p[2])
-
-  def p_expression_array_elements(self, p):
-    """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])
-
   # TODO(vtl): This is now largely redundant.
   def p_expression(self, p):
     """expression : binary_expression"""
     p[0] = ('EXPRESSION', p[1])
 
   # PLY lets us specify precedence of operators, but since we don't actually
   # evaluate them, we don't need that here.
   # TODO(vtl): We're going to need to evaluate them.
   def p_binary_expression(self, p):
     """binary_expression : unary_expression
@@ skipping 60 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