Add parsing for object 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 503 matching lines @@
 
   bool valid_type_;
   bool valid_binder_;
   bool string_;
   int arity_;
 };
 
 
 typedef PreParserList<PreParserType> PreParserTypeList;
 
+
+class PreParserTypeMember {
+ public:
+  static PreParserTypeMember Default(bool valid_type, bool valid_binder) {
+    return PreParserTypeMember(valid_type, valid_binder);
+  }
+  static PreParserTypeMember IndexSignature() {
+    return PreParserTypeMember(true, false);
+  }
+  bool IsValidType() const { return valid_type_; }
+  bool IsValidBindingIdentifierOrPattern() const { return valid_binder_; }
+
+  // Dummy implementation for making type_member->somefunc() work in both
+  // Parser and PreParser.
+  PreParserTypeMember* operator->() { return this; }
+
+ private:
+  PreParserTypeMember(bool valid_type, bool valid_binder)
+      : valid_type_(valid_type), valid_binder_(valid_binder) {}
+
+  bool valid_type_;
+  bool valid_binder_;
+};
+
+
+typedef PreParserList<PreParserTypeMember> PreParserTypeMembers;
+
+
 V8_INLINE PreParserFormalParameter
 PreParserFormalParameter::Unnamed(const PreParserType& type) {
   return PreParserFormalParameter(type.IsValidType(),
                                   type.IsValidBindingIdentifierOrPattern());
 }
 
 
 }  // namespace typesystem
 
 
@@ skipping 160 matching lines @@
                                          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 NewObjectType(
+      const typesystem::PreParserTypeMembers& members, bool valid_type,
+      bool valid_binder, 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,
+      const 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(
@@ skipping 19 matching lines @@
     return typesystem::PreParserFormalParameter::Unnamed(type);
   }
 
   typesystem::PreParserType NewTypeOrParameters(
       const typesystem::PreParserFormalParameters& parameters, int pos) {
     return typesystem::PreParserType::Parenthesized(parameters.IsValidType(),
                                                     parameters.length());
   }
 
   typesystem::PreParserTypeParameter NewTypeParameter(
-      PreParserIdentifier name, const typesystem::PreParserType& extends,
+      const PreParserIdentifier& name, const typesystem::PreParserType& extends,
       int pos) {
     return typesystem::PreParserTypeParameter::Default();
   }
 
+  typesystem::PreParserTypeMember NewTypeMember(
+      const PreParserExpression& property, bool optional,
+      const typesystem::PreParserTypeParameters& type_parameters,
+      const typesystem::PreParserFormalParameters& parameters,
+      const typesystem::PreParserType& result_type, bool valid_type,
+      bool valid_binder, int pos, bool constructor = false) {
+    return typesystem::PreParserTypeMember::Default(valid_type, valid_binder);
+  }
+
+  typesystem::PreParserTypeMember NewTypeMember(
+      const PreParserExpression& property,
+      typesystem::TypeMember::IndexType index_type,
+      const typesystem::PreParserType& result_type, int pos) {
+    return typesystem::PreParserTypeMember::IndexSignature();
+  }
+
   // Return the object itself as AstVisitor and implement the needed
   // dummy method right in this class.
   PreParserFactory* visitor() { return this; }
   int* ast_properties() {
     static int dummy = 42;
     return &dummy;
   }
 };
 
 
@@ skipping 39 matching lines @@
     typedef PreParserFormalParameters FormalParameters;
     typedef PreParserStatementList StatementList;
 
     struct TypeSystem {
       typedef typesystem::PreParserType Type;
       typedef typesystem::PreParserTypeList TypeList;
       typedef typesystem::PreParserTypeParameter TypeParameter;
       typedef typesystem::PreParserTypeParameters TypeParameters;
       typedef typesystem::PreParserFormalParameter FormalParameter;
       typedef typesystem::PreParserFormalParameters FormalParameters;
+      typedef typesystem::PreParserTypeMember TypeMember;
+      typedef typesystem::PreParserTypeMembers TypeMembers;
     };
 
     // For constructing objects returned by the traversing functions.
     typedef PreParserFactory Factory;
   };
 
   explicit PreParserTraits(PreParser* pre_parser) : pre_parser_(pre_parser) {}
 
   // Helper functions for recursive descent.
   static bool IsEval(PreParserIdentifier identifier) {
@@ skipping 157 matching lines @@
   }
   static typesystem::PreParserTypeList EmptyTypeList() {
     return typesystem::PreParserTypeList();
   }
   static typesystem::PreParserTypeParameters EmptyTypeParameters() {
     return typesystem::PreParserTypeParameters();
   }
   static typesystem::PreParserFormalParameters EmptyFormalParameters() {
     return typesystem::PreParserFormalParameters();
   }
+  static typesystem::PreParserFormalParameters NullFormalParameters() {
+    return typesystem::PreParserFormalParameters();
+  }
   static PreParserIdentifierList NullIdentifierList() {
     return PreParserIdentifierList();
   }
   static PreParserIdentifierList EmptyIdentifierList() {
     return PreParserIdentifierList();
   }
   static typesystem::PreParserType HoleTypeElement() {
     return typesystem::PreParserType::Default(false);
   }
+  static typesystem::PreParserTypeMembers EmptyTypeMembers() {
+    return typesystem::PreParserTypeMembers();
+  }
+  static typesystem::PreParserTypeMember EmptyTypeMember() {
+    return typesystem::PreParserTypeMember::Default(false, 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