[strong] Check super constructor calls

src/preparser.cc

 // Copyright 2011 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 <cmath>
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/conversions-inl.h"
 #include "src/conversions.h"
@@ skipping 175 matching lines @@
 
 void PreParser::ParseStatementList(int end_token, bool* ok) {
   // SourceElements ::
   //   (Statement)* <end_token>
 
   bool directive_prologue = true;
   while (peek() != end_token) {
     if (directive_prologue && peek() != Token::STRING) {
       directive_prologue = false;
     }
+    Token::Value token = peek();
+    Scanner::Location old_super_loc = function_state_->super_call_location();
     Statement statement = ParseStatementListItem(ok);
     if (!*ok) return;
+    Scanner::Location super_loc = function_state_->super_call_location();
+    if (is_strong(language_mode()) &&
+        i::IsConstructor(function_state_->kind()) &&
+        !old_super_loc.IsValid() && super_loc.IsValid() &&
+        token != Token::SUPER) {
+      ReportMessageAt(super_loc, "strong_super_call_nested");
+      *ok = false;
+      return;
+    }
     if (directive_prologue) {
       if (statement.IsUseStrictLiteral()) {
         scope_->SetLanguageMode(
             static_cast<LanguageMode>(scope_->language_mode() | STRICT_BIT));
       } else if (statement.IsUseStrongLiteral() && allow_strong_mode()) {
         scope_->SetLanguageMode(static_cast<LanguageMode>(
             scope_->language_mode() | STRICT_BIT | STRONG_BIT));
       } else if (!statement.IsStringLiteral()) {
         directive_prologue = false;
       }
@@ skipping 723 matching lines @@
   const bool use_strict_params = is_rest || IsConciseMethod(kind);
   CheckFunctionParameterNames(language_mode(), use_strict_params,
                               eval_args_error_loc, dupe_error_loc,
                               reserved_error_loc, CHECK_OK);
 
   if (is_strict(language_mode())) {
     int end_position = scanner()->location().end_pos;
     CheckStrictOctalLiteral(start_position, end_position, CHECK_OK);
   }
 
+  if (is_strong(language_mode()) && IsSubclassConstructor(kind)) {
+    if (!function_state.super_call_location().IsValid()) {
+      ReportMessageAt(function_name_location, "strong_super_call_missing",
+                      kReferenceError);
+      *ok = false;
+      return Expression::Default();
+    }
+  }
+
   return Expression::Default();
 }
 
 
 void PreParser::ParseLazyFunctionLiteralBody(bool* ok) {
   int body_start = position();
   ParseStatementList(Token::RBRACE, ok);
   if (!*ok) return;
 
   // Position right after terminal '}'.
@@ skipping 65 matching lines @@
   ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
   ParseArguments(ok);
 
   return Expression::Default();
 }
 
 #undef CHECK_OK
 
 
 } }  // v8::internal