Support Promise<T> syntax in the IDL parser.

tools/idl_parser/idl_ppapi_parser.py

 #!/usr/bin/env python
 # Copyright (c) 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.
 
 """ Parser for PPAPI IDL """
 
 #
 # IDL Parser
 #
@@ skipping 106 matching lines @@
   def p_StructMembers(self, p):
     """StructMembers : StructMember StructMembers
                      |"""
     if len(p) > 1:
       p[0] = ListFromConcat(p[1], p[2])
 
   def p_StructMember(self, p):
     """StructMember : ExtendedAttributeList Type identifier ';'"""
     p[0] = self.BuildNamed('Member', p, 3, ListFromConcat(p[1], p[2]))
 
-  # [24]
   def p_Typedef(self, p):
     """Typedef : TYPEDEF ExtendedAttributeListNoComments Type identifier ';'"""
     p[0] = self.BuildNamed('Typedef', p, 4, ListFromConcat(p[2], p[3]))
 
-  # [24.1]
   def p_TypedefFunc(self, p):
     """Typedef : TYPEDEF ExtendedAttributeListNoComments ReturnType identifier '(' ArgumentList ')' ';'"""
     args = self.BuildProduction('Arguments', p, 5, p[6])
     p[0] = self.BuildNamed('Callback', p, 4, ListFromConcat(p[2], p[3], args))
 
-  # [27]
   def p_ConstValue(self, p):
     """ConstValue : integer
                   | integer LSHIFT integer
                   | integer RSHIFT integer"""
     val = str(p[1])
     if len(p) > 2:
       val = "%s %s %s" % (p[1], p[2], p[3])
     p[0] = ListFromConcat(self.BuildAttribute('TYPE', 'integer'),
                           self.BuildAttribute('VALUE', val))
 
   def p_ConstValueStr(self, p):
     """ConstValue : string"""
     p[0] = ListFromConcat(self.BuildAttribute('TYPE', 'string'),
                           self.BuildAttribute('VALUE', p[1]))
 
   # Boolean & Float Literals area already BuildAttributes
   def p_ConstValueLiteral(self, p):
     """ConstValue : FloatLiteral
                   | BooleanLiteral """
     p[0] = p[1]
 
-  # [21]
   def p_EnumValueList(self, p):
     """EnumValueList : EnumValue EnumValues"""
     p[0] = ListFromConcat(p[1], p[2])
 
-  # [22]
   def p_EnumValues(self, p):
     """EnumValues : ',' EnumValue EnumValues
                   |"""
     if len(p) > 1:
       p[0] = ListFromConcat(p[2], p[3])
 
   def p_EnumValue(self, p):
     """EnumValue : ExtendedAttributeList identifier
                  | ExtendedAttributeList identifier '=' ConstValue"""
     p[0] = self.BuildNamed('EnumItem', p, 2, p[1])
     if len(p) > 3:
       p[0].AddChildren(p[4])
 
+  # Omit PromiseType, as it is a JS type.
+  def p_NonAnyType(self, p):
+    """NonAnyType : PrimitiveType TypeSuffix
+                  | identifier TypeSuffix
+                  | SEQUENCE '<' Type '>' Null"""
+    IDLParser.p_NonAnyType(self, p)
+
   def p_PrimitiveType(self, p):
     """PrimitiveType : IntegerType
                      | UnsignedIntegerType
                      | FloatType
                      | HandleType
                      | PointerType"""
     if type(p[1]) == str:
       p[0] = self.BuildNamed('PrimitiveType', p, 1)
     else:
       p[0] = p[1]
 
   def p_PointerType(self, p):
     """PointerType : STR_T
                    | MEM_T
                    | CSTR_T
                    | INTERFACE_T
                    | NULL"""
     p[0] = p[1]
 
   def p_HandleType(self, p):
     """HandleType : HANDLE_T
                   | PP_FILEHANDLE"""
     p[0] = p[1]
 
-  # [66]
   def p_FloatType(self, p):
     """FloatType : FLOAT_T
                  | DOUBLE_T"""
     p[0] = p[1]
 
-  # [67]
   def p_UnsignedIntegerType(self, p):
     """UnsignedIntegerType : UINT8_T
                            | UINT16_T
                            | UINT32_T
                            | UINT64_T"""
     p[0] = p[1]
 
 
-  # [68]
   def p_IntegerType(self, p):
     """IntegerType : CHAR
                    | INT8_T
                    | INT16_T
                    | INT32_T
                    | INT64_T"""
     p[0] = p[1]
 
   # These targets are no longer used
   def p_OptionalLong(self, p):
     """ """
     pass
 
   def p_UnrestrictedFloatType(self, p):
     """ """
     pass
 
   def p_null(self, p):
     """ """
     pass
 
+  def p_PromiseType(self, p):
+    """ """
+    pass
+
   # We only support:
   #    [ identifier ]
   #    [ identifier ( ArgumentList )]
   #    [ identifier ( ValueList )]
   #    [ identifier = identifier ]
   #    [ identifier = ( IdentifierList )]
   #    [ identifier = ConstValue ]
   #    [ identifier = identifier ( ArgumentList )]
   # [51] map directly to 74-77
   # [52-54, 56] are unsupported
@@ skipping 15 matching lines @@
   def p_ValueList(self, p):
     """ValueList : ConstValue ValueListCont"""
     p[0] = ListFromConcat(p[1], p[2])
 
   def p_ValueListCont(self, p):
     """ValueListCont : ValueList
                      |"""
     if len(p) > 1:
       p[0] = p[1]
 
-  # [76]
   def p_ExtendedAttributeIdentConst(self, p):
     """ExtendedAttributeIdentConst : identifier '=' ConstValue"""
     p[0] = self.BuildNamed('ExtAttribute', p, 1, p[3])
 
 
   def __init__(self, lexer, verbose=False, debug=False, mute_error=False):
     IDLParser.__init__(self, lexer, verbose, debug, mute_error)
 
 
 def main(argv):
@@ skipping 12 matching lines @@
   print '\n'.join(ast.Tree(accept_props=['PROD', 'TYPE', 'VALUE']))
   if errors:
     print '\nFound %d errors.\n' % errors
 
 
   return errors
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))