idl_parser: Add support for the record<K, V> WebIDL type.

tools/idl_parser/test_parser/interface_web.idl

 /* 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. */
 
 /* Test Interface productions
 
 Run with --test to generate an AST and verify that all comments accurately
 reflect the state of the Nodes.
 
 BUILD Type(Name)
@@ skipping 37 matching lines @@
 
 /* ERROR Unexpected ":" after identifier "MyIFaceInherit". */
 partial interface MyIFaceInherit : Foo {};
 
 /* TREE
  *Interface(MyIFaceMissingArgument)
  *  Operation(foo)
  *    Arguments()
  *      Argument(arg)
  *        Type()
- *          PrimitiveType(DOMString)
+ *          StringType(DOMString)
  *      Error(Missing argument.)
  *    Type()
  *      PrimitiveType(void)
  */
 interface MyIFaceMissingArgument {
   void foo(DOMString arg, );
 };
 
 /* TREE
  *Error(Unexpected keyword "double" after keyword "readonly".)
  */
 interface MyIFaceMissingAttribute {
   readonly double foo;
 };
 
 /* TREE
  *Interface(MyIFaceContainsUnresolvedConflictDiff)
  *  Operation(foo)
  *    Arguments()
  *    Type()
- *      PrimitiveType(DOMString)
+ *      StringType(DOMString)
  *  Error(Unexpected "<" after ";".)
  */
 interface MyIFaceContainsUnresolvedConflictDiff {
     DOMString foo();
 <<<<<< ours
     DOMString bar();
     iterable<long>;
 ======
 >>>>>> theirs
 };
 
 /* TREE
+ *Interface(MyIFaceWrongRecordKeyType)
+ *  Operation(foo)
+ *    Arguments()
+ *      Argument(arg)
+ *        Type()
+ *          Error(Unexpected identifier "int" after "<".)
+ *    Type()
+ *      PrimitiveType(void)
+ */
+interface MyIFaceWrongRecordKeyType {
+  void foo(record<int, ByteString> arg);
+};
+
+/* TREE
  *Interface(MyIFaceBig)
  *  Const(setString)
- *    PrimitiveType(DOMString)
+ *    StringType(DOMString)
  *    Value(NULL)
  */
 interface MyIFaceBig {
   const DOMString? setString = null;
 };
 
 /* TREE
  *Interface(MyIfaceEmptySequenceDefalutValue)
  *  Operation(foo)
  *    Arguments()
  *      Argument(arg)
  *        Type()
  *          Sequence()
  *            Type()
- *              PrimitiveType(DOMString)
+ *              StringType(DOMString)
  *        Default()
  *    Type()
  *      PrimitiveType(void)
  */
 interface MyIfaceEmptySequenceDefalutValue {
   void foo(optional sequence<DOMString> arg = []);
 };
 
 /* TREE
+ *Interface(MyIfaceWithRecords)
+ *  Operation(foo)
+ *    Arguments()
+ *      Argument(arg)
+ *        Type()
+ *          Record()
+ *            StringType(DOMString)
+ *            Type()
+ *              PrimitiveType(long)
+ *    Type()
+ *      PrimitiveType(void)
+ *  Operation(bar)
+ *    Arguments()
+ *      Argument(arg1)
+ *        Type()
+ *          Typeref(int)
+ *      Argument(arg2)
+ *        Type()
+ *          Record()
+ *            StringType(ByteString)
+ *            Type()
+ *              PrimitiveType(float)
+ *    Type()
+ *      PrimitiveType(double)
+ */
+interface MyIfaceWithRecords {
+  void foo(record<DOMString, long> arg);
+  double bar(int arg1, record<ByteString, float> arg2);
+};
+
+/* TREE
  *Interface(MyIFaceBig2)
  *  Const(nullValue)
- *    PrimitiveType(DOMString)
+ *    StringType(DOMString)
  *    Value(NULL)
  *  Const(longValue)
  *    PrimitiveType(long)
  *    Value(123)
  *  Const(longValue2)
  *    PrimitiveType(long long)
  *    Value(123)
  *  Attribute(myString)
  *    Type()
- *      PrimitiveType(DOMString)
+ *      StringType(DOMString)
  *  Attribute(readOnlyString)
  *    Type()
- *      PrimitiveType(DOMString)
+ *      StringType(DOMString)
  *  Attribute(staticString)
  *    Type()
- *      PrimitiveType(DOMString)
+ *      StringType(DOMString)
  *  Operation(myFunction)
  *    Arguments()
  *      Argument(myLong)
  *        Type()
  *          PrimitiveType(long long)
  *    Type()
  *      PrimitiveType(void)
  *  Operation(staticFunction)
  *    Arguments()
  *      Argument(myLong)
@@ skipping 13 matching lines @@
   static void staticFunction(long long myLong);
 };
 
 
 /* TREE
  *Interface(MyIFaceSpecials)
  *  Operation(set)
  *    Arguments()
  *      Argument(property)
  *        Type()
- *          PrimitiveType(DOMString)
+ *          StringType(DOMString)
  *    Type()
  *      PrimitiveType(void)
  *  Operation(_unnamed_)
  *    Arguments()
  *      Argument(property)
  *        Type()
- *          PrimitiveType(DOMString)
+ *          StringType(DOMString)
  *    Type()
  *      PrimitiveType(double)
  *  Operation(GetFiveSix)
  *    Arguments()
  *      Argument(arg)
  *        Type()
  *          Typeref(SomeType)
  *    Type()
  *      PrimitiveType(long long)
  *      Array(5)
  *        Array(6)
  */
 interface MyIFaceSpecials {
   setter creator void set(DOMString property);
   getter double (DOMString property);
   long long [5][6] GetFiveSix(SomeType arg);
 };
 
 /* TREE
  *Interface(MyIFaceStringifiers)
  *  Stringifier()
  *  Stringifier()
  *    Operation(_unnamed_)
  *      Arguments()
  *      Type()
- *        PrimitiveType(DOMString)
+ *        StringType(DOMString)
  *  Stringifier()
  *    Operation(namedStringifier)
  *      Arguments()
  *      Type()
- *        PrimitiveType(DOMString)
+ *        StringType(DOMString)
  *  Stringifier()
  *    Attribute(stringValue)
  *      Type()
- *        PrimitiveType(DOMString)
+ *        StringType(DOMString)
  */
 interface MyIFaceStringifiers {
   stringifier;
   stringifier DOMString ();
   stringifier DOMString namedStringifier();
   stringifier attribute DOMString stringValue;
 };
 
 /* TREE
  *Interface(MyExtendedAttributeInterface)
@@ skipping 50 matching lines @@
 
 /* TREE
  *Interface(MyIfaceIterable)
  *  Iterable()
  *    Type()
  *      PrimitiveType(long)
  *  Iterable()
  *    Type()
  *      PrimitiveType(double)
  *    Type()
- *      PrimitiveType(DOMString)
+ *      StringType(DOMString)
  *  LegacyIterable()
  *    Type()
  *      PrimitiveType(boolean)
  */
 interface MyIfaceIterable {
   iterable<long>;
   iterable<double, DOMString>;
   legacyiterable<boolean>;
 };
 
 /* TREE
  *Interface(MyIfaceMaplike)
  *  Maplike()
  *    Type()
  *      PrimitiveType(long)
  *    Type()
- *      PrimitiveType(DOMString)
+ *      StringType(DOMString)
  *  Maplike()
  *    Type()
  *      PrimitiveType(double)
  *    Type()
  *      PrimitiveType(boolean)
  */
 interface MyIfaceMaplike {
   readonly maplike<long, DOMString>;
   maplike<double, boolean>;
 };
@@ skipping 57 matching lines @@
   serializer = [getter];
   serializer = [name1, name2];
 };
 
 /* TREE
  *Interface(MyIfaceFrozenArray)
  *  Attribute(foo)
  *    Type()
  *      FrozenArray()
  *        Type()
- *          PrimitiveType(DOMString)
+ *          StringType(DOMString)
  */
 interface MyIfaceFrozenArray {
   readonly attribute FrozenArray<DOMString> foo;
 };
 
 /* TREE
  *Interface(MyIfaceUnion)
  *  Attribute(foo)
  *    Type()
  *      UnionType()
  *        Type()
- *          PrimitiveType(DOMString)
+ *          StringType(DOMString)
  *        Type()
  *          PrimitiveType(long)
  */
 interface MyIfaceUnion {
   attribute (DOMString or long) foo;
 };