ES6: instanceof error messages need updating.

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 6132 matching lines @@
   // if (!IS_RECEIVER(C)) throw MakeTypeError(kNonObjectInInstanceOfCheck);
   Statement* validate_C;
   {
     auto args = new (zone) ZoneList<Expression*>(1, zone);
     args->Add(factory->NewVariableProxy(var_C), zone);
     Expression* is_receiver_call =
         factory->NewCallRuntime(Runtime::kInlineIsJSReceiver, args, nopos);
     Expression* call =
         NewThrowTypeError(MessageTemplate::kNonObjectInInstanceOfCheck,
                           avfactory->empty_string(), pos);
-    Statement* throw_call = factory->NewExpressionStatement(call, nopos);
+    Statement* throw_call = factory->NewExpressionStatement(call, pos);
 
     validate_C =
         factory->NewIfStatement(is_receiver_call,
                                 factory->NewEmptyStatement(nopos),
                                 throw_call,
                                 nopos);
   }
 
   // let handler_result = C[Symbol.hasInstance];
   Variable* var_handler_result = scope->NewTemporary(avfactory->empty_string());
@@ skipping 22 matching lines @@
   {
     Expression* condition = factory->NewCompareOperation(
         Token::EQ_STRICT, factory->NewVariableProxy(var_handler_result),
         factory->NewUndefinedLiteral(nopos), nopos);
 
     Block* then_side = factory->NewBlock(nullptr, 3, false, nopos);
     {
       Expression* throw_expr =
           NewThrowTypeError(MessageTemplate::kCalledNonCallableInstanceOf,
                             avfactory->empty_string(), pos);
-      Statement* validate_C = CheckCallable(var_C, throw_expr);
+      Statement* validate_C = CheckCallable(var_C, throw_expr, pos);
 
       ZoneList<Expression*>* empty_args =
           new (zone) ZoneList<Expression*>(0, zone);
       Expression* ordinary_has_instance = factory->NewCallRuntime(
           Runtime::kInlineGetOrdinaryHasInstance, empty_args, pos);
       Expression* handler_proxy = factory->NewVariableProxy(var_handler_result);
       Expression* assignment_handler = factory->NewAssignment(
           Token::ASSIGN, handler_proxy, ordinary_has_instance, nopos);
       Statement* assignment_get_handler =
           factory->NewExpressionStatement(assignment_handler, nopos);
@@ skipping 48 matching lines @@
     block->statements()->Add(call_handler, zone);
 
     // Here is the desugared instanceof.
     instanceof = factory->NewDoExpression(block, var_handler_result, nopos);
     Rewriter::Rewrite(parser_, instanceof, avfactory);
   }
 
   return instanceof;
 }
 
-Statement* ParserTraits::CheckCallable(Variable* var, Expression* error) {
+Statement* ParserTraits::CheckCallable(Variable* var, Expression* error,
+                                       int pos) {
   auto factory = parser_->factory();
   auto avfactory = parser_->ast_value_factory();
   const int nopos = RelocInfo::kNoPosition;
   Statement* validate_var;
   {
     Expression* type_of = factory->NewUnaryOperation(
         Token::TYPEOF, factory->NewVariableProxy(var), nopos);
     Expression* function_literal =
         factory->NewStringLiteral(avfactory->function_string(), nopos);
     Expression* condition = factory->NewCompareOperation(
         Token::EQ_STRICT, type_of, function_literal, nopos);
 
-    Statement* throw_call = factory->NewExpressionStatement(error, nopos);
+    Statement* throw_call = factory->NewExpressionStatement(error, pos);
 
     validate_var = factory->NewIfStatement(
         condition, factory->NewEmptyStatement(nopos), throw_call, nopos);
   }
   return validate_var;
 }
 
 void ParserTraits::BuildIteratorClose(ZoneList<Statement*>* statements,
                                       Variable* iterator,
                                       Maybe<Variable*> input,
@@ skipping 258 matching lines @@
   }
 
   // if (!IS_CALLABLE(iteratorReturn)) {
   //   throw MakeTypeError(kReturnMethodNotCallable);
   // }
   Statement* check_return_callable;
   {
     Expression* throw_expr = NewThrowTypeError(
         MessageTemplate::kReturnMethodNotCallable,
         avfactory->empty_string(), nopos);
-    check_return_callable = CheckCallable(var_return, throw_expr);
+    check_return_callable = CheckCallable(var_return, throw_expr, nopos);
   }
 
   // try { %_Call(iteratorReturn, iterator) } catch (_) { }
   Statement* try_call_return;
   {
     auto args = new (zone) ZoneList<Expression*>(2, zone);
     args->Add(factory->NewVariableProxy(var_return), zone);
     args->Add(factory->NewVariableProxy(iterator), zone);
 
     Expression* call =
@@ skipping 229 matching lines @@
                         try_block, target);
     final_loop = target;
   }
 
   return final_loop;
 }
 
 
 }  // namespace internal
 }  // namespace v8