Add parsing for class declarations

src/parsing/parser.cc

 // 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.
 
 #include "src/parsing/parser.h"
 
 #include "src/api.h"
 #include "src/ast/ast.h"
 #include "src/ast/ast-expression-rewriter.h"
 #include "src/ast/ast-expression-visitor.h"
@@ skipping 4831 matching lines @@
   scope_->SetScopeName(name);
 
   VariableProxy* proxy = NULL;
   if (name != NULL) {
     proxy = NewUnresolved(name, CONST);
     Declaration* declaration =
         factory()->NewVariableDeclaration(proxy, CONST, block_scope, pos);
     Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
   }
 
+  // Parse optional type parameters.
+  typename TypeSystem::TypeParameters type_parameters =
+      this->NullTypeParameters();
+  if (scope_->typed() && peek() == Token::LT) {  // Braces required here.
+    type_parameters = ParseTypeParameters(CHECK_OK);
+  }
+  USE(type_parameters);  // TODO(nikolaos): really use them!
+
+  bool started_scope = false;
+
+  // Parse optional extends clause.
   Expression* extends = NULL;
   if (Check(Token::EXTENDS)) {
     block_scope->set_start_position(scanner()->location().end_pos);
+    started_scope = true;
+    // TODO(nikolaos): If this remains an expression, we have to explicitly
+    // allow type arguments.
     ExpressionClassifier classifier(this);
     extends = ParseLeftHandSideExpression(&classifier, CHECK_OK);
     RewriteNonPattern(&classifier, CHECK_OK);
-  } else {
+  }
+
+  // Parse optional implements clause.
+  ZoneList<typesystem::Type*>* implements = nullptr;
+  if (scope_->typed() && CheckContextualKeyword(CStrVector("implements"))) {
+    implements = new (zone()) ZoneList<typesystem::Type*>(1, zone());
+    if (!started_scope) {
+      block_scope->set_start_position(scanner()->location().end_pos);
+      started_scope = true;
+    }
+    do {
+      typesystem::Type* class_or_interface = ParseTypeReference(CHECK_OK);
+      implements->Add(class_or_interface, zone());
+    } while (Check(Token::COMMA));
+  }
+  USE(implements);  // TODO(nikolaos): really use it!
+
+  if (!started_scope) {
     block_scope->set_start_position(scanner()->location().end_pos);
   }
 
-
   ClassLiteralChecker checker(this);
   ZoneList<ObjectLiteral::Property*>* properties = NewPropertyList(4, zone());
   FunctionLiteral* constructor = NULL;
   bool has_seen_constructor = false;
 
   Expect(Token::LBRACE, CHECK_OK);
 
   const bool has_extends = extends != nullptr;
   while (peek() != Token::RBRACE) {
     if (Check(Token::SEMICOLON)) continue;
     FuncNameInferrer::State fni_state(fni_);
     const bool in_class = true;
     const bool is_static = false;
     bool is_computed_name = false;  // Classes do not care about computed
                                     // property names here.
     ExpressionClassifier classifier(this);
     const AstRawString* property_name = nullptr;
     ObjectLiteral::Property* property = ParsePropertyDefinition(
         &checker, in_class, has_extends, is_static, &is_computed_name,
         &has_seen_constructor, &classifier, &property_name, CHECK_OK);
+    // Ignore member variable declarations in typed mode.
+    if (property == nullptr) continue;
     RewriteNonPattern(&classifier, CHECK_OK);
 
     if (has_seen_constructor && constructor == NULL) {
       constructor = GetPropertyValue(property)->AsFunctionLiteral();
       DCHECK_NOT_NULL(constructor);
       constructor->set_raw_name(
           name != nullptr ? name : ast_value_factory()->empty_string());
     } else {
       properties->Add(property, zone());
     }
@@ skipping 2097 matching lines @@
                         try_block, target);
     final_loop = target;
   }
 
   return final_loop;
 }
 
 
 }  // namespace internal
 }  // namespace v8