Add parsing for tuple types

test/cctest/test-parsing.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 7378 matching lines @@
     "var x: ((number))",
     "var x: ((number))[]",
     "var x: ((number)[])",
     "var x: ((number[]))",
     "var x: ((a: string) => string) & ((b: number) => number)",
     "var x: number | any & string",
     "var s: (a: number, b?: string) => number",
     "var s: (a: number, b?: string, c?) => number",
     "var s: (a: number, b: string, c, ...d) => number",
     "var s: (a: number, b: string, c, ...d: string[]) => number",
+    "var s: (number) => number",
+    "var s: (number: any) => number",
+    "var s: (any: number) => number",
     NULL
   };
 
   const char* error_data[] = {
     "var x: ()",
     "var x: (a, b)",
     "var x: ((a, b))",
     "var x: ()[]",
     "var x: (()[])",
     "var x: (())[]",
@@ skipping 85 matching lines @@
   static const ParserFlag always_flags[] = {kAllowTypes};
   RunParserSyncTest(untyped_context_data, correct_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(typed_context_data, correct_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(untyped_context_data, error_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(typed_context_data, error_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
+
+TEST(TypedModeTupleTypes) {
+  const char* untyped_context_data[][2] = {{"", ""}, {NULL, NULL}};
+  const char* typed_context_data[][2] = {{"'use types'; ", ""}, {NULL, NULL}};
+
+  const char* correct_data[] = {
+    "var x: [number]",
+    "var x: [number, string]",
+    "var x: [number[], (a: string, b?: number) => boolean]",
+    "var f: ([]: number[]) => boolean",
+    "var f: ([x]: number[]) => boolean",
+    "var f: ([x, y]: number[]) => boolean",
+    "var f: ([x,, y]: number[]) => boolean",
+    "var f: ([, x,, y,,]: number[]) => boolean",
+    "var f: ([x, y, ...rest]: number[]) => boolean",
+    "var f: ([any]) => number",
+    "var f: ([number]: number[]) => number",
+    "var f: ([one, two, ...number]: number[]) => boolean",
+    NULL
+  };
+
+  const char* error_data[] = {
+    "var z: []",
+    "var z: [()]",
+    "var z: [number,]",
+    "var x: [number[], (a: string, b?: number)]",

[rossberg, 2016/03/17 16:51:37]

What about simpler cases like

[number, (a: string)]
[any, (a)]

[nickie, 2016/03/18 11:12:01]

I'm adding the first.  The second is valid, 'a' being a type reference. 
(There's no symbol table for types yet.)

+    "var z: [, number]",
+    "var z: [string,, number]",
+    "var z: [string,, ...number]",
+    NULL
+  };
+
+  static const ParserFlag always_flags[] = {kAllowTypes};
+  RunParserSyncTest(untyped_context_data, correct_data, kError, NULL, 0,
+                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(typed_context_data, correct_data, kSuccess, NULL, 0,
+                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(untyped_context_data, error_data, kError, NULL, 0,
+                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(typed_context_data, error_data, kError, NULL, 0,
+                    always_flags, arraysize(always_flags));
+}