Add parsing for tuple types

src/parsing/preparser.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_PREPARSER_H
 #define V8_PARSING_PREPARSER_H
 
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/hashmap.h"
@@ skipping 418 matching lines @@
 
 
 class PreParserFormalParameter {
  public:
   static PreParserFormalParameter Named() {
     return PreParserFormalParameter(false, false);
   }
   V8_INLINE static PreParserFormalParameter Unnamed(const PreParserType& type);
 
   bool IsValidType() const { return valid_type_; }
-  bool IsSimpleIdentifier() const { return simple_identifier_; }
+  bool IsValidBindingIdentifierOrPattern() const { return valid_binder_; }
 
  private:
-  PreParserFormalParameter(bool valid, bool simple)
-      : valid_type_(valid), simple_identifier_(simple) {}
+  PreParserFormalParameter(bool valid_type, bool valid_binder)
+      : valid_type_(valid_type), valid_binder_(valid_binder) {}
 
   bool valid_type_;
-  bool simple_identifier_;
+  bool valid_binder_;
 };
 
 
 typedef PreParserList<PreParserTypeParameter> PreParserTypeParameters;
 
 
 class PreParserFormalParameters
     : public PreParserList<PreParserFormalParameter> {
  public:
   explicit PreParserFormalParameters(bool valid = false, int arity = 0)
       : PreParserList<PreParserFormalParameter>(arity), valid_type_(valid) {}
 
   PreParserFormalParameters* operator->() { return this; }
 
   void Add(const PreParserFormalParameter& param, void* dummy) {
     PreParserList<PreParserFormalParameter>::Add(param, dummy);
     valid_type_ = length() == 1 && param.IsValidType();
   }
 
   bool IsValidType() const { return valid_type_; }
 
  private:
   bool valid_type_;
 };
 
 
 class PreParserType {
  public:
-  static PreParserType Default(bool valid = true) {
-    return PreParserType(valid, false, false);
+  static PreParserType Default(bool valid_type = true,
+                               bool valid_binder = false) {
+    return PreParserType(valid_type, valid_binder, false);
   }
   static PreParserType Reference(bool simple) {
     return PreParserType(true, simple, false);
   }
-  static PreParserType Parenthesized(bool valid, int arity) {
-    return PreParserType(valid, false, false, arity);
+  static PreParserType Parenthesized(bool valid_type, int arity) {
+    return PreParserType(valid_type, false, false, arity);
   }
   static PreParserType StringLiteral() {
     return PreParserType(true, false, true);
   }
 
   // Dummy implementation for making type->somefunc() work in both Parser
   // and PreParser.
   PreParserType* operator->() { return this; }
 
   PreParserType Uncover(bool* ok) {
     *ok = valid_type_;
     return *this;
   }
 
   PreParserFormalParameters AsValidParameterList(Zone* zone, bool* ok) const {
     if (arity_ >= 0) return PreParserFormalParameters(arity_);
     *ok = false;
     return PreParserFormalParameters();
   }
 
   bool IsValidType() const { return valid_type_; }
-  bool IsSimpleIdentifier() const { return simple_identifier_; }
+  bool IsValidBindingIdentifierOrPattern() const { return valid_binder_; }
   bool IsStringLiteralType() const { return string_; }
 
-  PreParserIdentifier AsSimpleIdentifier() const {
-    DCHECK(simple_identifier_);
-    return PreParserIdentifier::Default();
-  }
-
  private:
-  PreParserType(bool valid, bool simple, bool string, int arity = -1)
-      : valid_type_(valid),
-        simple_identifier_(simple),
+  PreParserType(bool valid_type, bool valid_binder, bool string, int arity = -1)
+      : valid_type_(valid_type),
+        valid_binder_(valid_binder),
         string_(string),
         arity_(arity) {}
 
   bool valid_type_;
-  bool simple_identifier_;
+  bool valid_binder_;
   bool string_;
   int arity_;
 };
 
 
-typedef PreParserList<PreParserType> PreParserTypeArguments;
+typedef PreParserList<PreParserType> PreParserTypeList;
 
 V8_INLINE PreParserFormalParameter
 PreParserFormalParameter::Unnamed(const PreParserType& type) {
   return PreParserFormalParameter(type.IsValidType(),
-                                  type.IsSimpleIdentifier());
+                                  type.IsValidBindingIdentifierOrPattern());
 }
 
 
 }  // namespace typesystem
 
 
 class PreParserFactory {
  public:
   explicit PreParserFactory(void* unused_value_factory) {}
   PreParserExpression NewStringLiteral(PreParserIdentifier identifier,
@@ skipping 125 matching lines @@
                                 int expr_pos) {
     return PreParserExpression::Spread(expression);
   }
 
   PreParserExpression NewEmptyParentheses(int pos) {
     return PreParserExpression::Default();
   }
 
   typesystem::PreParserType NewPredefinedType(
       typesystem::PredefinedType::Kind kind, int pos) {
-    return typesystem::PreParserType::Default();
+    return typesystem::PreParserType::Default(
+        true, kind != typesystem::PredefinedType::kVoidType);
   }
 
   typesystem::PreParserType NewThisType(int pos) {
     return typesystem::PreParserType::Default();
   }
 
   typesystem::PreParserType NewUnionType(const typesystem::PreParserType& left,
                                          const typesystem::PreParserType& right,
                                          int pos) {
     return typesystem::PreParserType::Default();
   }
 
   typesystem::PreParserType NewIntersectionType(
       const typesystem::PreParserType& left,
       const typesystem::PreParserType& right, int pos) {
     return typesystem::PreParserType::Default();
   }
 
   typesystem::PreParserType NewArrayType(const typesystem::PreParserType& base,
                                          int pos) {
     return typesystem::PreParserType::Default();
   }
 
+  typesystem::PreParserType NewTupleType(
+      const typesystem::PreParserTypeList& elements, bool valid_type,
+      bool valid_binder, bool spread, int pos) {
+    return typesystem::PreParserType::Default(valid_type, valid_binder);
+  }
+
   typesystem::PreParserType NewFunctionType(
       const typesystem::PreParserTypeParameters& type_parameters,
       const typesystem::PreParserFormalParameters& parameters,
       typesystem::PreParserType result_type, int pos,
       bool constructor = false) {
     return typesystem::PreParserType::Default();
   }
 
   typesystem::PreParserType NewStringLiteralType(
       const PreParserIdentifier& string, int pos) {
     return typesystem::PreParserType::StringLiteral();
   }
 
   typesystem::PreParserType NewTypeReference(
       const PreParserIdentifier& name,
-      const typesystem::PreParserTypeArguments& type_arguments, int pos) {
+      const typesystem::PreParserTypeList& type_arguments, int pos) {
     return typesystem::PreParserType::Reference(type_arguments.length() == 0);
   }
 
   typesystem::PreParserType NewQueryType(
       const PreParserIdentifier& name,
       const PreParserIdentifierList& property_names, int pos) {
     return typesystem::PreParserType::Default();
   }
 
   typesystem::PreParserFormalParameter NewFormalParameter(
-      const PreParserIdentifier& name, bool optional, bool spread,
+      const typesystem::PreParserType& binder, bool optional, bool spread,
       const typesystem::PreParserType& type, int pos) {
     return typesystem::PreParserFormalParameter::Named();
   }
 
   typesystem::PreParserFormalParameter NewFormalParameter(
       const typesystem::PreParserType& type, int pos) {
     return typesystem::PreParserFormalParameter::Unnamed(type);
   }
 
   typesystem::PreParserType NewTypeOrParameters(
@@ skipping 55 matching lines @@
     typedef PreParserExpression ObjectLiteralProperty;
     typedef PreParserExpression Literal;
     typedef PreParserExpressionList ExpressionList;
     typedef PreParserExpressionList PropertyList;
     typedef PreParserIdentifier FormalParameter;
     typedef PreParserFormalParameters FormalParameters;
     typedef PreParserStatementList StatementList;
 
     struct TypeSystem {
       typedef typesystem::PreParserType Type;
-      typedef typesystem::PreParserTypeArguments TypeArguments;
+      typedef typesystem::PreParserTypeList TypeList;
       typedef typesystem::PreParserTypeParameter TypeParameter;
       typedef typesystem::PreParserTypeParameters TypeParameters;
       typedef typesystem::PreParserFormalParameter FormalParameter;
       typedef typesystem::PreParserFormalParameters FormalParameters;
     };
 
     // For constructing objects returned by the traversing functions.
     typedef PreParserFactory Factory;
   };
 
@@ skipping 142 matching lines @@
   }
   static PreParserExpression EmptyFunctionLiteral() {
     return PreParserExpression::Default();
   }
   static PreParserExpressionList NullExpressionList() {
     return PreParserExpressionList();
   }
   static typesystem::PreParserType EmptyType() {
     return typesystem::PreParserType::Default(false);
   }
-  static typesystem::PreParserTypeArguments NullTypeArguments() {
-    return typesystem::PreParserTypeArguments();
+  static typesystem::PreParserTypeList NullTypeList() {
+    return typesystem::PreParserTypeList();
   }
   static typesystem::PreParserTypeParameters NullTypeParameters() {
     return typesystem::PreParserTypeParameters();
   }
   static bool IsNullTypeParameters(
       const typesystem::PreParserTypeParameters& typ_pars) {
     return typ_pars.length() == 0;
   }
-  static typesystem::PreParserTypeArguments EmptyTypeArguments() {
-    return typesystem::PreParserTypeArguments();
+  static typesystem::PreParserTypeList EmptyTypeList() {
+    return typesystem::PreParserTypeList();
   }
   static typesystem::PreParserTypeParameters EmptyTypeParameters() {
     return typesystem::PreParserTypeParameters();
   }
   static typesystem::PreParserFormalParameters EmptyFormalParameters() {
     return typesystem::PreParserFormalParameters();
   }
   static PreParserIdentifierList NullIdentifierList() {
     return PreParserIdentifierList();
   }
   static PreParserIdentifierList EmptyIdentifierList() {
     return PreParserIdentifierList();
   }
+  static typesystem::PreParserType HoleTypeElement() {
+    return typesystem::PreParserType::Default(false);
+  }
 
   // Odd-ball literal creators.
   static PreParserExpression GetLiteralTheHole(int position,
                                                PreParserFactory* factory) {
     return PreParserExpression::Default();
   }
 
   // Producing data during the recursive descent.
   PreParserIdentifier GetSymbol(Scanner* scanner);
   PreParserIdentifier GetNumberAsSymbol(Scanner* scanner);
@@ skipping 401 matching lines @@
     const PreParserFormalParameters& parameters, FunctionKind kind,
     FunctionLiteral::FunctionType function_type, bool* ok) {
   return pre_parser_->ParseEagerFunctionBody(function_name, pos, parameters,
                                              kind, function_type, ok);
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PREPARSER_H