Add parsing for type queries

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 323 matching lines @@
   // These functions make list->Add(some_expression) work (and do nothing).
   explicit PreParserList(int length = 0) : length_(length) {}
   PreParserList* operator->() { return this; }
   void Add(T, void*) { ++length_; }
   int length() const { return length_; }
  private:
   int length_;
 };
 
 
+typedef PreParserList<PreParserIdentifier> PreParserIdentifierList;
 typedef PreParserList<PreParserExpression> PreParserExpressionList;
 
 
 class PreParserStatement {
  public:
   static PreParserStatement Default() {
     return PreParserStatement(kUnknownStatement);
   }
 
   static PreParserStatement Jump() {
@@ skipping 355 matching lines @@
       const PreParserIdentifier& string, int pos) {
     return typesystem::PreParserType::StringLiteral();
   }
 
   typesystem::PreParserType NewTypeReference(
       const PreParserIdentifier& name,
       const typesystem::PreParserTypeArguments& 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& type, int pos) {
     return typesystem::PreParserFormalParameter::Named();
   }
 
   typesystem::PreParserFormalParameter NewFormalParameter(
       const typesystem::PreParserType& type, int pos) {
     return typesystem::PreParserFormalParameter::Unnamed(type);
   }
@@ skipping 42 matching lines @@
     // PreParser doesn't need to store generator variables.
     typedef void GeneratorVariable;
 
     typedef int AstProperties;
 
     typedef v8::internal::ExpressionClassifier<PreParserTraits>
         ExpressionClassifier;
 
     // Return types for traversing functions.
     typedef PreParserIdentifier Identifier;
+    typedef PreParserIdentifierList IdentifierList;
     typedef PreParserExpression Expression;
     typedef PreParserExpression YieldExpression;
     typedef PreParserExpression FunctionLiteral;
     typedef PreParserExpression ClassLiteral;
     typedef PreParserExpression ObjectLiteralProperty;
     typedef PreParserExpression Literal;
     typedef PreParserExpressionList ExpressionList;
     typedef PreParserExpressionList PropertyList;
     typedef PreParserIdentifier FormalParameter;
     typedef PreParserFormalParameters FormalParameters;
@@ skipping 176 matching lines @@
   }
   static typesystem::PreParserTypeArguments EmptyTypeArguments() {
     return typesystem::PreParserTypeArguments();
   }
   static typesystem::PreParserTypeParameters EmptyTypeParameters() {
     return typesystem::PreParserTypeParameters();
   }
   static typesystem::PreParserFormalParameters EmptyFormalParameters() {
     return typesystem::PreParserFormalParameters();
   }
+  static PreParserIdentifierList NullIdentifierList() {
+    return PreParserIdentifierList();
+  }
+  static PreParserIdentifierList EmptyIdentifierList() {
+    return PreParserIdentifierList();
+  }
 
   // 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