Mojo: Reformat parser_unittest.py.

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 55 matching lines @@
 class Parser(object):
 
   def __init__(self, lexer, source, filename):
     self.tokens = lexer.tokens
     self.source = source
     self.filename = filename
 
   def p_root(self, p):
     """root : import root
             | module
-            | definitions"""
+            | 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])]
       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 definitions RBRACE"""
+    """module : attribute_section MODULE identifier LBRACE definition_list \
+                    RBRACE"""
     p[0] = ('MODULE', p[3], p[1], p[5])
 
-  def p_definitions(self, p):
-    """definitions : definition definitions
-                   | """
+  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
                   | interface
                   | enum
                   | const"""
     p[0] = p[1]
 
   def p_attribute_section(self, p):
-    """attribute_section : LBRACKET attributes RBRACKET
+    """attribute_section : LBRACKET attribute_list RBRACKET
                          | """
     if len(p) > 3:
       p[0] = p[2]
 
-  def p_attributes(self, p):
-    """attributes : attribute
-                  | attribute COMMA attributes
-                  | """
+  def p_attribute_list(self, p):
+    """attribute_list : attribute
+                      | attribute COMMA attribute_list
+                      | """
     if len(p) == 2:
       p[0] = _ListFromConcat(p[1])
     elif len(p) > 3:
       p[0] = _ListFromConcat(p[1], p[3])
 
   def p_attribute(self, p):
     """attribute : NAME EQUALS evaled_literal
                  | NAME EQUALS NAME"""
     p[0] = ('ATTRIBUTE', p[1], p[3])
 
@@ skipping 31 matching lines @@
 
   def p_interface_body(self, p):
     """interface_body : method interface_body
                       | enum interface_body
                       | const interface_body
                       | """
     if len(p) > 1:
       p[0] = _ListFromConcat(p[1], p[2])
 
   def p_response(self, p):
-    """response : RESPONSE LPAREN parameters RPAREN
+    """response : RESPONSE LPAREN parameter_list RPAREN
                 | """
     if len(p) > 3:
       p[0] = p[3]
 
   def p_method(self, p):
-    """method : NAME ordinal LPAREN parameters RPAREN response SEMI"""
+    """method : NAME ordinal LPAREN parameter_list RPAREN response SEMI"""
     p[0] = ('METHOD', p[1], p[4], p[2], p[6])
 
-  def p_parameters(self, p):
-    """parameters : parameter
-                  | parameter COMMA parameters
-                  | """
+  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(self, p):
     """parameter : typename NAME ordinal"""
     p[0] = ast.Parameter(p[1], p[2], p[3],
@@ skipping 30 matching lines @@
 
   def p_array(self, p):
     """array : typename LBRACKET RBRACKET"""
     p[0] = p[1] + "[]"
 
   def p_fixed_array(self, p):
     """fixed_array : typename LBRACKET INT_CONST_DEC RBRACKET"""
     value = int(p[3])
     if value == 0 or value > _MAX_ARRAY_SIZE:
       raise ParseError(self.filename, "Fixed array size %d invalid" % value,
-                       lineno=p.lineno(1),
-                       snippet=self._GetSnippet(p.lineno(1)))
+                       lineno=p.lineno(3),
+                       snippet=self._GetSnippet(p.lineno(3)))
     p[0] = p[1] + "[" + p[3] + "]"
 
   def p_interfacerequest(self, p):
     """interfacerequest : identifier AMP"""
     p[0] = p[1] + "&"
 
   def p_ordinal(self, p):
     """ordinal : ORDINAL
                | """
     if len(p) > 1:
       value = int(p[1][1:])
       if value > _MAX_ORDINAL_VALUE:
         raise ParseError(self.filename, "Ordinal value %d too large:" % value,
                          lineno=p.lineno(1),
                          snippet=self._GetSnippet(p.lineno(1)))
       p[0] = ast.Ordinal(value, filename=self.filename, lineno=p.lineno(1))
     else:
       p[0] = ast.Ordinal(None)
 
   def p_enum(self, p):
-    """enum : ENUM NAME LBRACE enum_fields RBRACE SEMI"""
+    """enum : ENUM NAME LBRACE enum_field_list RBRACE SEMI"""
     p[0] = ('ENUM', p[2], p[4])
 
-  def p_enum_fields(self, p):
-    """enum_fields : enum_field
-                   | enum_field COMMA enum_fields
-                   | """
+  def p_enum_field_list(self, p):
+    """enum_field_list : enum_field
+                       | enum_field COMMA enum_field_list
+                       | """
     if len(p) == 2:
       p[0] = _ListFromConcat(p[1])
     elif len(p) > 3:
       p[0] = _ListFromConcat(p[1], p[3])
 
   def p_enum_field(self, p):
     """enum_field : NAME
                   | NAME EQUALS constant"""
     if len(p) == 2:
       p[0] = ('ENUM_FIELD', p[1], None)
@@ skipping 53 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