Add parsing for tuple types

src/ast/ast.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_AST_AST_H_
 #define V8_AST_AST_H_
 
 #include "src/assembler.h"
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/modules.h"
@@ skipping 88 matching lines @@
   EXPRESSION_NODE_LIST(V)
 
 // Optional type nodes are intentionally not in in AST_NODE_LIST.
 // Visitors should not have to worry about them.
 #define TYPESYSTEM_NODE_LIST(V) \
   V(PredefinedType)             \
   V(ThisType)                   \
   V(UnionType)                  \
   V(IntersectionType)           \
   V(ArrayType)                  \
+  V(TupleType)                  \
   V(FunctionType)               \
   V(TypeParameter)              \
   V(FormalParameter)            \
   V(TypeReference)              \
   V(StringLiteralType)          \
   V(QueryType)                  \
   V(TypeOrParameters)
 
 // Forward declarations
 class AstNodeFactory;
@@ skipping 2809 matching lines @@
  private:
   EmptyParentheses(Zone* zone, int pos) : Expression(zone, pos) {}
 };
 
 
 // Nodes for the optional type system.
 namespace typesystem {
 
 class FormalParameter;
 
 class Type : public AstNode {

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

With all the new syntax it seems that this is now more than just "a type":
binder patterns are also represented as Type nodes, although they are not types
as such. Perhaps add a clarifying comment to that end.

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

Done.  I copied some information from the design doc as comments, both here and
in other classes that are used as covers.

  public:
   // Uncovers the case of a single, parenthesized valid type.
   V8_INLINE Type* Uncover(bool* ok);
 
   V8_INLINE ZoneList<FormalParameter*>* AsValidParameterList(Zone* zone,
                                                              bool* ok) const;
 
-  V8_INLINE bool IsSimpleIdentifier() const;
-  V8_INLINE const AstRawString* AsSimpleIdentifier() const;
+  V8_INLINE bool IsValidType() const;
+  V8_INLINE bool IsValidBindingIdentifierOrPattern() const;
 
  protected:
   explicit Type(Zone* zone, int position) : AstNode(position) {}
 };
 
 
 class PredefinedType : public Type {
  public:
   DECLARE_NODE_TYPE(PredefinedType)
 
   enum Kind {
     kAnyType,
     kNumberType,
     kBooleanType,
     kStringType,
     kSymbolType,
     kVoidType
   };
 
   Kind kind() const { return kind_; }
+  bool IsValidBindingIdentifier() const { return kind_ != kVoidType; }
 
  protected:
   PredefinedType(Zone* zone, Kind kind, int pos)
       : Type(zone, pos), kind_(kind) {}
 
  private:
   Kind kind_;
 };
 
 
@@ skipping 47 matching lines @@
   Type* base() const { return base_; }
 
  protected:
   ArrayType(Zone* zone, Type* base, int pos) : Type(zone, pos), base_(base) {}
 
  private:
   Type* base_;
 };
 
 
+class TupleType : public Type {
+ public:
+  DECLARE_NODE_TYPE(TupleType)
+
+  ZoneList<Type*>* elements() const { return elements_; }
+  bool IsValidType() const { return valid_type_; }
+  bool IsValidBindingPattern() const { return valid_binder_; }
+  bool spread() const { return spread_; }
+
+ protected:
+  TupleType(Zone* zone, ZoneList<Type*>* elements, bool valid_type,
+            bool valid_binder, bool spread, int pos)
+      : Type(zone, pos),
+        elements_(elements),
+        valid_type_(valid_type),
+        valid_binder_(valid_binder),
+        spread_(spread) {}
+
+ private:
+  ZoneList<Type*>* elements_;
+  bool valid_type_;
+  bool valid_binder_;
+  bool spread_;
+};
+
+
 class TypeParameter : public AstNode {
  public:
   DECLARE_NODE_TYPE(TypeParameter)
 
   const AstRawString* name() const { return name_; }
   Type* extends() const { return extends_; }
 
  protected:
   TypeParameter(Zone* zone, const AstRawString* name, Type* extends, int pos)
       : AstNode(pos), name_(name), extends_(extends) {}
 
  private:
   const AstRawString* name_;
   Type* extends_;
 };
 
 class FormalParameter : public AstNode {
  public:
   DECLARE_NODE_TYPE(FormalParameter)
 
-  bool IsValidType() const { return name_ == nullptr; }
+  bool IsValidType() const {
+    return binder_ == nullptr && type_->IsValidType();
+  }
 
   void MakeValidParameter(bool* ok) {
-    if (name_ != nullptr) return;
-    if (optional_ || spread_ || !type_->IsSimpleIdentifier()) {
+    if (binder_ != nullptr) return;
+    if (optional_ || spread_ || !type_->IsValidBindingIdentifierOrPattern()) {
       *ok = false;
       return;
     }
-    name_ = type_->AsSimpleIdentifier();
+    binder_ = type_;
     type_ = nullptr;
   }
 
-  const AstRawString* name() const { return name_; }
+  Type* binder() const { return binder_; }
   bool optional() const { return optional_; }
   bool spread() const { return spread_; }
   Type* type() const { return type_; }
 
  protected:
-  FormalParameter(Zone* zone, const AstRawString* name, bool optional,
-                  bool spread, Type* type, int pos)
+  FormalParameter(Zone* zone, Type* binder, bool optional, bool spread,
+                  Type* type, int pos)
       : AstNode(pos),
-        name_(name),
+        binder_(binder),
         optional_(optional),
         spread_(spread),
         type_(type) {}
   FormalParameter(Zone* zone, Type* type, int pos)
       : AstNode(pos),
-        name_(nullptr),
+        binder_(nullptr),
         optional_(false),
         spread_(false),
         type_(type) {}
 
   friend class Type;
 
  private:
-  const AstRawString* name_;
+  Type* binder_;
   bool optional_;
   bool spread_;
   Type* type_;
 };
 
 
 class FunctionType : public Type {
  public:
   DECLARE_NODE_TYPE(FunctionType)
 
@@ skipping 20 matching lines @@
 };
 
 
 class TypeReference : public Type {
  public:
   DECLARE_NODE_TYPE(TypeReference)
 
   const AstRawString* name() const { return name_; }
   ZoneList<Type*>* type_arguments() const { return type_arguments_; }
 
+  bool IsValidBindingIdentifier() const {
+    // TODO(nikolaos): This should probably exclude restricted identifiers.
+    return type_arguments() == nullptr;
+  }
+
  protected:
   TypeReference(Zone* zone, const AstRawString* name,
                 ZoneList<Type*>* type_arguments, int pos)
       : Type(zone, pos), name_(name), type_arguments_(type_arguments) {}
 
  private:
   const AstRawString* name_;
   ZoneList<Type*>* type_arguments_;
 };
 
@@ skipping 40 matching lines @@
   ZoneList<FormalParameter*>* parameters() const { return parameters_; }
 
  protected:
   TypeOrParameters(Zone* zone, ZoneList<FormalParameter*>* parameters, int pos)
       : Type(zone, pos), parameters_(parameters) {}
 
  private:
   ZoneList<FormalParameter*>* parameters_;
 };
 
-V8_INLINE bool Type::IsSimpleIdentifier() const {
-  const TypeReference* ref = AsTypeReference();
-  if (ref == nullptr) return false;
-  return ref->type_arguments() == nullptr;
+V8_INLINE bool Type::IsValidType() const {
+  if (IsTypeOrParameters()) {
+    ZoneList<FormalParameter*>* parameters = AsTypeOrParameters()->parameters();
+    return parameters->length() == 1 && parameters->at(0)->IsValidType();
+  }
+  if (IsTupleType()) return AsTupleType()->IsValidType();
+  return true;
 }
 
-V8_INLINE const AstRawString* Type::AsSimpleIdentifier() const {
-  const TypeReference* ref = AsTypeReference();
-  DCHECK_NOT_NULL(ref);
-  DCHECK_NULL(ref->type_arguments());
-  return ref->name();
+V8_INLINE bool Type::IsValidBindingIdentifierOrPattern() const {
+  if (IsTypeReference()) return AsTypeReference()->IsValidBindingIdentifier();
+  if (IsTupleType()) return AsTupleType()->IsValidBindingPattern();
+  if (IsPredefinedType()) return AsPredefinedType()->IsValidBindingIdentifier();
+  return false;
 }
 
 V8_INLINE Type* Type::Uncover(bool* ok) {
-  if (!IsTypeOrParameters()) return this;
-  ZoneList<FormalParameter*>* parameters = AsTypeOrParameters()->parameters();
-  if (parameters->length() == 1 && parameters->at(0)->IsValidType())
-    return parameters->at(0)->type();
+  if (IsTypeOrParameters()) {
+    ZoneList<FormalParameter*>* parameters = AsTypeOrParameters()->parameters();
+    if (parameters->length() == 1 && parameters->at(0)->IsValidType())
+      return parameters->at(0)->type();
+  } else if (IsTupleType()) {
+    if (AsTupleType()->IsValidType()) return this;
+  } else {
+    return this;
+  }
   *ok = false;
   return nullptr;
 }
 
 V8_INLINE ZoneList<FormalParameter*>* Type::AsValidParameterList(
     Zone* zone, bool* ok) const {
   if (!IsTypeOrParameters()) {
     *ok = false;
     return nullptr;
   }
@@ skipping 571 matching lines @@
                                                     typesystem::Type* right,
                                                     int pos) {
     return new (local_zone_)
         typesystem::IntersectionType(local_zone_, left, right, pos);
   }
 
   typesystem::ArrayType* NewArrayType(typesystem::Type* base, int pos) {
     return new (local_zone_) typesystem::ArrayType(local_zone_, base, pos);
   }
 
+  typesystem::TupleType* NewTupleType(ZoneList<typesystem::Type*>* elements,
+                                      bool valid_type, bool valid_binder,
+                                      bool spread, int pos) {
+    return new (local_zone_) typesystem::TupleType(
+        local_zone_, elements, valid_type, valid_binder, spread, pos);
+  }
+
   typesystem::FunctionType* NewFunctionType(
       ZoneList<typesystem::TypeParameter*>* type_parameters,
       ZoneList<typesystem::FormalParameter*>* parameters,
       typesystem::Type* result_type, int pos, bool constructor = false) {
     return new (local_zone_)
         typesystem::FunctionType(local_zone_, type_parameters, parameters,
                                  result_type, pos, constructor);
   }
 
   typesystem::TypeReference* NewTypeReference(
       const AstRawString* name, ZoneList<typesystem::Type*>* type_arguments,
       int pos) {
     return new (local_zone_)
         typesystem::TypeReference(local_zone_, name, type_arguments, pos);
   }
 
   typesystem::StringLiteralType* NewStringLiteralType(
       const AstRawString* string, int pos) {
     return new (local_zone_)
         typesystem::StringLiteralType(local_zone_, string, pos);
   }
 
   typesystem::QueryType* NewQueryType(
       const AstRawString* name, ZoneList<const AstRawString*>* property_names,
       int pos) {
     return new (local_zone_)
         typesystem::QueryType(local_zone_, name, property_names, pos);
   }
 
-  typesystem::FormalParameter* NewFormalParameter(const AstRawString* name,
+  typesystem::FormalParameter* NewFormalParameter(typesystem::Type* binder,
                                                   bool optional, bool spread,
                                                   typesystem::Type* type,
                                                   int pos) {
     return new (local_zone_) typesystem::FormalParameter(
-        local_zone_, name, optional, spread, type, pos);
+        local_zone_, binder, optional, spread, type, pos);
   }
 
   typesystem::FormalParameter* NewFormalParameter(typesystem::Type* type,
                                                   int pos) {
     return new (local_zone_)
         typesystem::FormalParameter(local_zone_, type, pos);
   }
 
   typesystem::TypeOrParameters* NewTypeOrParameters(
       ZoneList<typesystem::FormalParameter*>* parameters, int pos) {
@@ skipping 93 matching lines @@
         : NULL;                                                               \
   }
 TYPESYSTEM_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_