new classes: special construct stub for derived classs and TDZ for `this`.

src/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_PREPARSER_H
 #define V8_PREPARSER_H
 
 #include "src/v8.h"
 
 #include "src/bailout-reason.h"
@@ skipping 494 matching lines @@
 
   ExpressionT ParsePrimaryExpression(bool* ok);
   ExpressionT ParseExpression(bool accept_IN, bool* ok);
   ExpressionT ParseArrayLiteral(bool* ok);
   ExpressionT ParsePropertyName(IdentifierT* name, bool* is_get, bool* is_set,
                                 bool* is_static, bool* is_computed_name,
                                 bool* ok);
   ExpressionT ParseObjectLiteral(bool* ok);
   ObjectLiteralPropertyT ParsePropertyDefinition(ObjectLiteralChecker* checker,
                                                  bool in_class, bool is_static,
+                                                 bool has_extends,
                                                  bool* is_computed_name,
                                                  bool* has_seen_constructor,
                                                  bool* ok);
   typename Traits::Type::ExpressionList ParseArguments(bool* ok);
   ExpressionT ParseAssignmentExpression(bool accept_IN, bool* ok);
   ExpressionT ParseYieldExpression(bool* ok);
   ExpressionT ParseConditionalExpression(bool accept_IN, bool* ok);
   ExpressionT ParseBinaryExpression(int prec, bool accept_IN, bool* ok);
   ExpressionT ParseUnaryExpression(bool* ok);
   ExpressionT ParsePostfixExpression(bool* ok);
@@ skipping 769 matching lines @@
     return PreParserExpression::Default();
   }
   PreParserExpression NewThrowSyntaxError(
       const char* type, Handle<Object> arg, int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewThrowTypeError(
       const char* type, Handle<Object> arg, int pos) {
     return PreParserExpression::Default();
   }
-  PreParserScope NewScope(PreParserScope* outer_scope, ScopeType scope_type) {
+  PreParserScope NewScope(PreParserScope* outer_scope, ScopeType scope_type,
+                          FunctionKind kind = kNormalFunction) {
     return PreParserScope(outer_scope, scope_type);
   }
 
   // Reporting errors.
   void ReportMessageAt(Scanner::Location location,
                        const char* message,
                        const char* arg = NULL,
                        bool is_reference_error = false);
   void ReportMessageAt(int start_pos,
                        int end_pos,
@@ skipping 746 matching lines @@
   return this->IsArrayIndex(*name, &index)
              ? factory()->NewNumberLiteral(index, pos)
              : factory()->NewStringLiteral(*name, pos);
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ObjectLiteralPropertyT
 ParserBase<Traits>::ParsePropertyDefinition(ObjectLiteralChecker* checker,
                                             bool in_class, bool is_static,
+                                            bool has_extends,
                                             bool* is_computed_name,
                                             bool* has_seen_constructor,
                                             bool* ok) {
   DCHECK(!in_class || is_static || has_seen_constructor != NULL);
   ExpressionT value = this->EmptyExpression();
   IdentifierT name = this->EmptyIdentifier();
   bool is_get = false;
   bool is_set = false;
   bool name_is_static = false;
   bool is_generator = allow_harmony_object_literals_ && Check(Token::MUL);
@@ skipping 38 matching lines @@
         return this->EmptyObjectLiteralProperty();
       }
 
       if (*has_seen_constructor) {
         ReportMessageAt(scanner()->location(), "duplicate_constructor");
         *ok = false;
         return this->EmptyObjectLiteralProperty();
       }
 
       *has_seen_constructor = true;
-      kind = FunctionKind::kNormalFunction;
+      kind = has_extends ? FunctionKind::kSubclassConstructor
+                         : FunctionKind::kNormalFunction;
     }
 
     if (!*is_computed_name && checker != NULL) {
       checker->CheckProperty(name_token, kValueProperty,
                              CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
     }
 
     value = this->ParseFunctionLiteral(
         name, scanner()->location(),
         false,  // reserved words are allowed here
         kind, RelocInfo::kNoPosition, FunctionLiteral::ANONYMOUS_EXPRESSION,
         FunctionLiteral::NORMAL_ARITY,
         CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
     return factory()->NewObjectLiteralProperty(name_expression, value,
                                                ObjectLiteralProperty::COMPUTED,
                                                is_static, *is_computed_name);
 
   } else if (in_class && name_is_static && !is_static) {
     // static MethodDefinition
-    return ParsePropertyDefinition(checker, true, true, is_computed_name, NULL,
-                                   ok);
+    return ParsePropertyDefinition(checker, true, true, has_extends,
+                                   is_computed_name, nullptr, ok);
 
   } else if (is_get || is_set) {
     // Accessor
     name = this->EmptyIdentifier();
     bool dont_care = false;
     name_token = peek();
 
     name_expression = ParsePropertyName(
         &name, &dont_care, &dont_care, &dont_care, is_computed_name,
         CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
@@ skipping 71 matching lines @@
 
   ObjectLiteralChecker checker(this, strict_mode());
 
   Expect(Token::LBRACE, CHECK_OK);
 
   while (peek() != Token::RBRACE) {
     if (fni_ != NULL) fni_->Enter();
 
     const bool in_class = false;
     const bool is_static = false;
+    const bool has_extends = false;
     bool is_computed_name = false;
     ObjectLiteralPropertyT property = this->ParsePropertyDefinition(
-        &checker, in_class, is_static, &is_computed_name, NULL, CHECK_OK);
+        &checker, in_class, is_static, has_extends, &is_computed_name, NULL,
+        CHECK_OK);
 
     if (is_computed_name) {
       has_computed_names = true;
     }
 
     // Mark top-level object literals that contain function literals and
     // pretenure the literal so it can be added as a constant function
     // property. (Parser only.)
     this->CheckFunctionLiteralInsideTopLevelObjectLiteral(scope_, property,
                                                           &has_function);
@@ skipping 800 matching lines @@
       DCHECK(IsAccessorAccessorConflict(old_type, type));
       // Both accessors of the same type.
       parser()->ReportMessage("accessor_get_set");
     }
     *ok = false;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H