Add parsing for type queries

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 64 matching lines @@
 //   };
 //   // ...
 // };
 
 template <typename Traits>
 class ParserBase : public Traits {
  public:
   // Shorten type names defined by Traits.
   typedef typename Traits::Type::Expression ExpressionT;
   typedef typename Traits::Type::Identifier IdentifierT;
+  typedef typename Traits::Type::IdentifierList IdentifierListT;
   typedef typename Traits::Type::FormalParameter FormalParameterT;
   typedef typename Traits::Type::FormalParameters FormalParametersT;
   typedef typename Traits::Type::FunctionLiteral FunctionLiteralT;
   typedef typename Traits::Type::Literal LiteralT;
   typedef typename Traits::Type::ObjectLiteralProperty ObjectLiteralPropertyT;
   typedef typename Traits::Type::StatementList StatementListT;
   typedef typename Traits::Type::ExpressionClassifier ExpressionClassifier;
   typedef typename Traits::Type::TypeSystem TypeSystem;
 
   ParserBase(Zone* zone, Scanner* scanner, uintptr_t stack_limit,
@@ skipping 740 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);
+  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);
     return type;
@@ skipping 2426 matching lines @@
       } else if (CheckContextualKeyword(CStrVector("number"))) {
         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 {
-        // TODO(nikolaos): Missing typeof.
         IdentifierT name = ParseIdentifierName(CHECK_OK_TYPE);
         typename TypeSystem::TypeArguments type_arguments =
             this->NullTypeArguments();
         if (peek() == Token::LT) {  // Braces required here.
           type_arguments = ParseTypeArguments(CHECK_OK_TYPE);
         }
         type = factory()->NewTypeReference(name, type_arguments, 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;
@@ skipping 19 matching lines @@
     while (Check(Token::LBRACK)) {  // Braces required here
       Expect(Token::RBRACK, CHECK_OK_TYPE);
       type = factory()->NewArrayType(type, pos);
     }
   }
 
   return type;
 }
 
 
+template <typename Traits>
+typename ParserBase<Traits>::IdentifierListT

[rossberg, 2016/03/17 12:34:09]

Doesn't make much sense to allow identifier lists in queries, since that would
only be useful if we had TypeScript-style namespaces. I suggest to simplify to
plain identifiers.

[rossberg, 2016/03/17 12:37:17]

Ah sorry, I was confused. Disregard that comment.

+ParserBase<Traits>::ParsePropertyNameList(bool* ok) {
+  Expect(Token::PERIOD, CHECK_OK_CUSTOM(NullIdentifierList));
+  IdentifierListT property_names = this->EmptyIdentifierList();
+  do {
+    IdentifierT property_name =
+        ParseIdentifierName(CHECK_OK_CUSTOM(NullIdentifierList));
+    property_names->Add(property_name, zone());
+  } while (Check(Token::PERIOD));
+  return property_names;
+}
+
+
 #undef CHECK_OK
 #undef CHECK_OK_CUSTOM
 #undef CHECK_OK_TYPE
 
 
 template <typename Traits>
 void ParserBase<Traits>::ObjectLiteralChecker::CheckProperty(
     Token::Value property, PropertyKind type, bool is_static, bool is_generator,
     bool* ok) {
   DCHECK(!is_static);
@@ skipping 44 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H