Mojo: Mojom: Disallow trailing commas in parameter lists.

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 52 matching lines @@
 
 # We have methods which look like they could be functions:
 # pylint: disable=R0201
 class Parser(object):
 
   def __init__(self, lexer, source, filename):
     self.tokens = lexer.tokens
     self.source = source
     self.filename = filename
 
+  # Names of functions
+  #
+  # In general, we name functions after the left-hand-side of the rule(s) that
+  # they handle. E.g., |p_foo_bar| for a rule |foo_bar : ...|.
+  #
+  # There may be multiple functions handling rules for the same left-hand-side;
+  # then we name the functions |p_foo_bar_N| (for left-hand-side |foo_bar|),
+  # where N is a number (numbered starting from 1). Note that using multiple
+  # functions is actually more efficient than having single functions handle
+  # multiple rules (and, e.g., distinguishing them by examining |len(p)|).
+  #
+  # It's also possible to have a function handling multiple rules with different
+  # left-hand-sides. We do not do this.
+  #
+  # See http://www.dabeaz.com/ply/ply.html#ply_nn25 for more details.
+
   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':
@@ skipping 87 matching lines @@
   def p_response(self, p):
     """response : RESPONSE LPAREN parameter_list RPAREN
                 | """
     if len(p) > 3:
       p[0] = p[3]
 
   def p_method(self, p):
     """method : NAME ordinal LPAREN parameter_list RPAREN response SEMI"""
     p[0] = ('METHOD', p[1], p[4], p[2], p[6])
 
-  def p_parameter_list(self, p):
-    """parameter_list : parameter
-                      | parameter COMMA parameter_list
-                      | """
-    if len(p) == 1:
-      p[0] = []
-    elif len(p) == 2:
-      p[0] = [p[1]]
-    else:
-      p[0] = [p[1]] + p[3]
+  def p_parameter_list_1(self, p):
+    """parameter_list : """
+    p[0] = []
+
+  def p_parameter_list_2(self, p):
+    """parameter_list : nonempty_parameter_list"""
+    p[0] = p[1]
+
+  def p_nonempty_parameter_list_1(self, p):
+    """nonempty_parameter_list : parameter"""
+    p[0] = [p[1]]
+
+  def p_nonempty_parameter_list_2(self, p):
+    """nonempty_parameter_list : nonempty_parameter_list COMMA parameter"""
+    p[0] = p[1]
+    p[0].append(p[3])
 
   def p_parameter(self, p):
     """parameter : typename NAME ordinal"""
     p[0] = ast.Parameter(p[1], p[2], p[3],
                          filename=self.filename, lineno=p.lineno(1))
 
   def p_typename(self, p):
     """typename : basictypename
                 | array
                 | fixed_array
@@ skipping 126 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