Add parsing for tuple types

src/parsing/parser-base.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_PARSING_PARSER_BASE_H
 #define V8_PARSING_PARSER_BASE_H
 
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/hashmap.h"
@@ skipping 824 matching lines @@
   }
 
   // Parsing optional types.
   typename TypeSystem::Type ParseValidType(bool* ok);
   typename TypeSystem::Type ParseValidTypeOrStringLiteral(bool* ok);
   typename TypeSystem::Type ParseType(bool* ok);
   typename TypeSystem::Type ParseUnionOrIntersectionOrPrimaryType(bool* ok);
   typename TypeSystem::Type ParseIntersectionOrPrimaryType(bool* ok);
   typename TypeSystem::Type ParsePrimaryTypeOrParameterList(bool* ok);
   typename TypeSystem::TypeParameters ParseTypeParameters(bool* ok);
-  typename TypeSystem::TypeArguments ParseTypeArguments(bool* ok);
+  typename TypeSystem::TypeList ParseTypeArguments(bool* ok);
   IdentifierListT ParsePropertyNameList(bool* ok);
 
   typename TypeSystem::Type ValidateType(typename TypeSystem::Type type,
                                          Scanner::Location location, bool* ok) {
     typename TypeSystem::Type result = type->Uncover(ok);
     if (*ok) {
       if (!result->IsStringLiteralType()) return result;
       *ok = false;
     }
     ReportMessageAt(location, MessageTemplate::kInvalidType);
@@ skipping 2299 matching lines @@
       extends = ParseValidType(CHECK_OK_CUSTOM(NullTypeParameters));
     }
     parameters->Add(factory()->NewTypeParameter(name, extends, pos), zone());
   } while (Check(Token::COMMA));
   Expect(Token::GT, CHECK_OK_CUSTOM(NullTypeParameters));
   return parameters;
 }
 
 
 template <typename Traits>
-typename ParserBase<Traits>::TypeSystem::TypeArguments
+typename ParserBase<Traits>::TypeSystem::TypeList
 ParserBase<Traits>::ParseTypeArguments(bool* ok) {
-  Expect(Token::LT, CHECK_OK_CUSTOM(NullTypeArguments));
-  typename TypeSystem::TypeArguments arguments = this->EmptyTypeArguments();
+  Expect(Token::LT, CHECK_OK_CUSTOM(NullTypeList));
+  typename TypeSystem::TypeList arguments = this->EmptyTypeList();
   do {
     typename TypeSystem::Type type =
-        ParseValidType(CHECK_OK_CUSTOM(NullTypeArguments));
+        ParseValidType(CHECK_OK_CUSTOM(NullTypeList));
     arguments->Add(type, zone());
   } while (Check(Token::COMMA));
-  Expect(Token::GT, CHECK_OK_CUSTOM(NullTypeArguments));
+  Expect(Token::GT, CHECK_OK_CUSTOM(NullTypeList));
   return arguments;
 }
 
 
 template <typename Traits>
 typename ParserBase<Traits>::TypeSystem::Type
 ParserBase<Traits>::ParseUnionOrIntersectionOrPrimaryType(bool* ok) {
   Scanner::Location type_location = scanner()->peek_location();
   typename TypeSystem::Type type =
       ParseIntersectionOrPrimaryType(CHECK_OK_TYPE);
@@ skipping 39 matching lines @@
   typename TypeSystem::Type type = this->EmptyType();
   switch (peek()) {
     case Token::LPAREN: {
       Consume(Token::LPAREN);
       typename TypeSystem::FormalParameters parameters =
           this->EmptyFormalParameters();
       if (peek() != Token::RPAREN) {
         do {
           Scanner::Location parameter_location = scanner()->peek_location();
           if (Check(Token::ELLIPSIS)) {
+            int name_pos = peek_position();
             IdentifierT name = ParseIdentifierName(CHECK_OK_TYPE);
             if (Check(Token::COLON)) {  // Braces required here.
               type = ParseValidType(CHECK_OK_TYPE);
             } else {
               type = this->EmptyType();
             }
-            parameters->Add(
-                factory()->NewFormalParameter(name, false, true, type,
-                                              parameter_location.beg_pos),
-                zone());
+            parameters->Add(factory()->NewFormalParameter(
+                                factory()->NewTypeReference(
+                                    name, this->NullTypeList(), name_pos),
+                                false, true, type, parameter_location.beg_pos),
+                            zone());
             break;
           }
           type = ParseType(CHECK_OK_TYPE);
           if (peek() == Token::CONDITIONAL || peek() == Token::COLON) {
-            if (!type->IsSimpleIdentifier()) {
+            if (!type->IsValidBindingIdentifierOrPattern()) {
               ReportUnexpectedToken(Next());
               *ok = false;
               return this->EmptyType();
             }
             bool optional = Check(Token::CONDITIONAL);
-            IdentifierT name = type->AsSimpleIdentifier();
+            typename TypeSystem::Type of_type = this->EmptyType();
             if (Check(Token::COLON)) {  // Braces required here.
               type = ParseValidTypeOrStringLiteral(CHECK_OK_TYPE);
-            } else {
-              type = this->EmptyType();
             }
             parameters->Add(
-                factory()->NewFormalParameter(name, optional, false, type,
+                factory()->NewFormalParameter(type, optional, false, of_type,
                                               parameter_location.beg_pos),
                 zone());
           } else {
             type = ValidateType(type, parameter_location, CHECK_OK_TYPE);
             parameters->Add(
                 factory()->NewFormalParameter(type, parameter_location.beg_pos),
                 zone());
           }
         } while (Check(Token::COMMA));
       }
@@ skipping 12 matching lines @@
         type = factory()->NewPredefinedType(
             typesystem::PredefinedType::kNumberType, pos);
       } else if (CheckContextualKeyword(CStrVector("string"))) {
         type = factory()->NewPredefinedType(
             typesystem::PredefinedType::kStringType, pos);
       } else if (CheckContextualKeyword(CStrVector("symbol"))) {
         type = factory()->NewPredefinedType(
             typesystem::PredefinedType::kSymbolType, pos);
       } else {
         IdentifierT name = ParseIdentifierName(CHECK_OK_TYPE);
-        typename TypeSystem::TypeArguments type_arguments =
-            this->NullTypeArguments();
+        typename TypeSystem::TypeList type_arguments = this->NullTypeList();
         if (peek() == Token::LT) {  // Braces required here.
           type_arguments = ParseTypeArguments(CHECK_OK_TYPE);
         }
         type = factory()->NewTypeReference(name, type_arguments, pos);
       }
       break;
     }
+    case Token::LBRACK: {
+      Consume(Token::LBRACK);
+      typename TypeSystem::TypeList elements = this->EmptyTypeList();
+      bool valid_type = false, valid_binder = true, spread = false;
+      bool trailing_comma = false;
+      if (peek() != Token::RBRACK) {
+        valid_type = true;
+        do {
+          if (Check(Token::COMMA)) {
+            typename TypeSystem::Type type_element = this->HoleTypeElement();
+            elements->Add(type_element, zone());
+            valid_type = false;
+            trailing_comma = true;
+            continue;
+          } else {
+            trailing_comma = false;
+          }
+          if (Check(Token::ELLIPSIS)) {
+            typename TypeSystem::Type type_element = ParseType(CHECK_OK_TYPE);
+            elements->Add(type_element, zone());
+            valid_type = false;
+            spread = true;
+            break;
+          }
+          typename TypeSystem::Type type_element = ParseType(CHECK_OK_TYPE);
+          elements->Add(type_element, zone());
+          if (!type_element->IsValidType()) valid_type = false;
+          if (!type_element->IsValidBindingIdentifierOrPattern())
+            valid_binder = false;
+          if (peek() != Token::RBRACK) {  // Braces required here.
+            Expect(Token::COMMA, CHECK_OK_TYPE);
+            trailing_comma = true;
+          }
+        } while (peek() != Token::RBRACK);
+      }
+      Consume(Token::RBRACK);
+      type = factory()->NewTupleType(elements, valid_type && !trailing_comma,
+                                     valid_binder, spread, pos);
+      break;
+    }
     case Token::TYPEOF: {
       Consume(Token::TYPEOF);
       IdentifierT name = ParseIdentifierName(CHECK_OK_TYPE);
       IdentifierListT property_names = this->NullIdentifierList();
       if (peek() == Token::PERIOD) {  // Braces required here.
         property_names = ParsePropertyNameList(CHECK_OK_TYPE);
       }
       type = factory()->NewQueryType(name, property_names, pos);
       break;
     }
     case Token::VOID: {
       Consume(Token::VOID);
       type = factory()->NewPredefinedType(typesystem::PredefinedType::kVoidType,
                                           pos);
       break;
     }
     case Token::THIS: {
       Consume(Token::THIS);
       type = factory()->NewThisType(pos);
       break;
     }
     // TODO(nikolaos): Missing object types.
-    // TODO(nikolaos): Missing tuple types.
     case Token::STRING: {
       Consume(Token::STRING);
       IdentifierT str = this->GetSymbol(scanner());
       type = factory()->NewStringLiteralType(str, pos);
       break;
     }
     default:
       ReportUnexpectedToken(Next());
       *ok = false;
       return type;
@@ skipping 84 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H