Reland "Migrate error messages, part 2."

src/execution.cc

 // Copyright 2014 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/execution.h"
 
 #include "src/bootstrapper.h"
 #include "src/codegen.h"
 #include "src/deoptimizer.h"
 #include "src/isolate-inl.h"
+#include "src/messages.h"
 #include "src/vm-state-inl.h"
 
 namespace v8 {
 namespace internal {
 
 StackGuard::StackGuard()
     : isolate_(NULL) {
 }
 
 
@@ skipping 251 matching lines @@
   // Objects created through the API can have an instance-call handler
   // that should be used when calling the object as a function.
   if (fun->IsHeapObject() &&
       HeapObject::cast(fun)->map()->has_instance_call_handler()) {
     return Handle<JSFunction>(
         isolate->native_context()->call_as_function_delegate());
   }
 
   // If the Object doesn't have an instance-call handler we should
   // throw a non-callable exception.
-  THROW_NEW_ERROR(isolate, NewTypeError("called_non_callable",
-                                        i::HandleVector<i::Object>(&object, 1)),
+  THROW_NEW_ERROR(isolate,
+                  NewTypeError(MessageTemplate::kCalledNonCallable, object),
                   Object);
 }
 
 
 Handle<Object> Execution::GetConstructorDelegate(Isolate* isolate,
                                                  Handle<Object> object) {
   DCHECK(!object->IsJSFunction());
 
   // If you return a function from here, it will be called when an
   // attempt is made to call the given object as a constructor.
@@ skipping 34 matching lines @@
   // Objects created through the API can have an instance-call handler
   // that should be used when calling the object as a function.
   if (fun->IsHeapObject() &&
       HeapObject::cast(fun)->map()->has_instance_call_handler()) {
     return Handle<JSFunction>(
         isolate->native_context()->call_as_constructor_delegate());
   }
 
   // If the Object doesn't have an instance-call handler we should
   // throw a non-callable exception.
-  THROW_NEW_ERROR(isolate, NewTypeError("called_non_callable",
-                                        i::HandleVector<i::Object>(&object, 1)),
+  THROW_NEW_ERROR(isolate,
+                  NewTypeError(MessageTemplate::kCalledNonCallable, object),
                   Object);
 }
 
 
 void StackGuard::EnableInterrupts() {
   ExecutionAccess access(isolate_);
   if (has_pending_interrupts(access)) {
     set_interrupt_limits(access);
   }
 }
@@ skipping 336 matching lines @@
   }
 
   isolate_->counters()->stack_interrupts()->Increment();
   isolate_->counters()->runtime_profiler_ticks()->Increment();
   isolate_->runtime_profiler()->OptimizeNow();
 
   return isolate_->heap()->undefined_value();
 }
 
 } }  // namespace v8::internal