Add parsing for type aliases

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 70 matching lines @@
  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::Statement StatementT;
   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,
              v8::Extension* extension, AstValueFactory* ast_value_factory,
              ParserRecorder* log, typename Traits::Type::Parser this_object)
       : Traits(this_object),
         parenthesized_function_(false),
         scope_(NULL),
@@ skipping 744 matching lines @@
   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::TypeList ParseTypeArguments(bool* ok);
   IdentifierListT ParsePropertyNameList(bool* ok);
   typename TypeSystem::TypeMember ParseTypeMember(bool* ok);
+  StatementT ParseTypeAliasDeclaration(int pos, 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 2726 matching lines @@
     type = ParseType(CHECK_OK_CUSTOM(EmptyTypeMember));
     if (!type->IsValidType()) valid_type = false;
     if (!type->IsValidBindingIdentifierOrPattern()) valid_binder = false;
   }
   return factory()->NewTypeMember(property, optional, type_parameters,
                                   parameters, type, valid_type, valid_binder,
                                   pos, has_new);
 }
 
 
+template <typename Traits>
+typename ParserBase<Traits>::StatementT
+ParserBase<Traits>::ParseTypeAliasDeclaration(int pos, bool* ok) {
+  // TypeAliasDeclaration ::
+  //   'type' BindingIdentifier [ TypeParameters ] '=' Type ';'
+  typename ParserBase<Traits>::StatementT empty =
+      factory()->NewEmptyStatement(pos);
+  IdentifierT name = ParseIdentifierName(ok);
+  if (!*ok) return empty;
+  // Parse optional type parameters.
+  typename TypeSystem::TypeParameters type_parameters =
+      this->NullTypeParameters();
+  if (peek() == Token::LT) {
+    type_parameters = ParseTypeParameters(ok);
+    if (!*ok) return empty;
+  }
+  Expect(Token::ASSIGN, ok);
+  if (!*ok) return empty;
+  typename TypeSystem::Type type = ParseValidType(ok);
+  if (!*ok) return empty;
+  ExpectSemicolon(ok);
+  if (!*ok) return empty;
+  USE(name);  // TODO(nikolaos): really use them!
+  USE(type_parameters);
+  USE(type);
+  return empty;
+}
+
+
 #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