Better message location for 'super(...)' restriction error.

src/compiler.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/v8.h"
 
 #include "src/compiler.h"
 
 #include "src/ast-numbering.h"
 #include "src/ast-this-access-visitor.h"
@@ skipping 744 matching lines @@
   if (!info->shared_info().is_null()) {
     FunctionLiteral* lit = info->function();
     info->shared_info()->set_ast_node_count(lit->ast_node_count());
     MaybeDisableOptimization(info->shared_info(), lit->dont_optimize_reason());
     info->shared_info()->set_dont_cache(lit->flags()->Contains(kDontCache));
   }
   return true;
 }
 
 
-static void ThrowSuperConstructorCheckError(CompilationInfo* info) {
+static void ThrowSuperConstructorCheckError(CompilationInfo* info,
+                                            Statement* stmt) {
   MaybeHandle<Object> obj = info->isolate()->factory()->NewTypeError(
       "super_constructor_call", HandleVector<Object>(nullptr, 0));
   Handle<Object> exception;
   if (!obj.ToHandle(&exception)) return;
 
-  FunctionLiteral* lit = info->function();
-  MessageLocation location(info->script(), lit->start_position(),
-                           lit->end_position());
+  MessageLocation location(info->script(), stmt->position(), stmt->position());
   USE(info->isolate()->Throw(*exception, &location));
 }
 
 
 static bool CheckSuperConstructorCall(CompilationInfo* info) {
   FunctionLiteral* function = info->function();
   if (!function->uses_super_constructor_call()) return true;
 
   if (function->is_default_constructor()) return true;
 
@@ skipping 10 matching lines @@
       super_call_index++;
       continue;
     }
     if (stmt->IsEmptyStatement()) {
       super_call_index++;
       continue;
     }
     break;
   }
 
-  ExpressionStatement* exprStm =
-      body->at(super_call_index)->AsExpressionStatement();
+  Statement* stmt = body->at(super_call_index);
+  ExpressionStatement* exprStm = stmt->AsExpressionStatement();
   if (exprStm == nullptr) {
-    ThrowSuperConstructorCheckError(info);
+    ThrowSuperConstructorCheckError(info, stmt);
     return false;
   }
   Call* callExpr = exprStm->expression()->AsCall();
   if (callExpr == nullptr) {
-    ThrowSuperConstructorCheckError(info);
+    ThrowSuperConstructorCheckError(info, stmt);
     return false;
   }
 
   if (!callExpr->expression()->IsSuperReference()) {
-    ThrowSuperConstructorCheckError(info);
+    ThrowSuperConstructorCheckError(info, stmt);
     return false;
   }
 
   ZoneList<Expression*>* arguments = callExpr->arguments();
 
   AstThisAccessVisitor this_access_visitor(info->zone());
   this_access_visitor.VisitExpressions(arguments);
 
   if (this_access_visitor.HasStackOverflow()) return false;
   if (this_access_visitor.UsesThis()) {
-    ThrowSuperConstructorCheckError(info);
+    ThrowSuperConstructorCheckError(info, stmt);
     return false;
   }
 
   return true;
 }
 
 
 bool Compiler::Analyze(CompilationInfo* info) {
   DCHECK(info->function() != NULL);
   if (!Rewriter::Rewrite(info)) return false;
@@ skipping 736 matching lines @@
   AllowHandleDereference allow_deref;
   bool tracing_on = info()->IsStub()
       ? FLAG_trace_hydrogen_stubs
       : (FLAG_trace_hydrogen &&
          info()->closure()->PassesFilter(FLAG_trace_hydrogen_filter));
   return (tracing_on &&
       base::OS::StrChr(const_cast<char*>(FLAG_trace_phase), name_[0]) != NULL);
 }
 
 } }  // namespace v8::internal