Migrate error messages, part 8.

src/promise.js

 // 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.
 
 var $promiseCreate;
 var $promiseResolve;
 var $promiseReject;
 var $promiseChain;
 var $promiseCatch;
 var $promiseThen;
@@ skipping 13 matching lines @@
 var promiseStatus = GLOBAL_PRIVATE("Promise#status");
 var promiseValue = GLOBAL_PRIVATE("Promise#value");
 var promiseOnResolve = GLOBAL_PRIVATE("Promise#onResolve");
 var promiseOnReject = GLOBAL_PRIVATE("Promise#onReject");
 var promiseRaw = GLOBAL_PRIVATE("Promise#raw");
 var promiseHasHandler = %PromiseHasHandlerSymbol();
 var lastMicrotaskId = 0;
 
 var GlobalPromise = function Promise(resolver) {
   if (resolver === promiseRaw) return;
-  if (!%_IsConstructCall()) throw MakeTypeError('not_a_promise', [this]);
+  if (!%_IsConstructCall()) throw MakeTypeError(kNotAPromise, this);
   if (!IS_SPEC_FUNCTION(resolver))
-    throw MakeTypeError('resolver_not_a_function', [resolver]);
+    throw MakeTypeError(kResolverNotAFunction, resolver);
   var promise = PromiseInit(this);
   try {
     %DebugPushPromise(promise, Promise);
     resolver(function(x) { PromiseResolve(promise, x) },
              function(r) { PromiseReject(promise, r) });
   } catch (e) {
     PromiseReject(promise, e);
   } finally {
     %DebugPopPromise();
   }
@@ skipping 52 matching lines @@
   }
   return x;
 }
 
 function PromiseHandle(value, handler, deferred) {
   try {
     %DebugPushPromise(deferred.promise, PromiseHandle);
     DEBUG_PREPARE_STEP_IN_IF_STEPPING(handler);
     var result = handler(value);
     if (result === deferred.promise)
-      throw MakeTypeError('promise_cyclic', [result]);
+      throw MakeTypeError(kPromiseCyclic, result);
     else if (IsPromise(result))
       %_CallFunction(result, deferred.resolve, deferred.reject, PromiseChain);
     else
       deferred.resolve(result);
   } catch (exception) {
     try { deferred.reject(exception); } catch (e) { }
   } finally {
     %DebugPopPromise();
   }
 }
@@ skipping 97 matching lines @@
 }
 
 // Simple chaining.
 
 function PromiseChain(onResolve, onReject) {  // a.k.a. flatMap
   onResolve = IS_UNDEFINED(onResolve) ? PromiseIdResolveHandler : onResolve;
   onReject = IS_UNDEFINED(onReject) ? PromiseIdRejectHandler : onReject;
   var deferred = %_CallFunction(this.constructor, PromiseDeferred);
   switch (GET_PRIVATE(this, promiseStatus)) {
     case UNDEFINED:
-      throw MakeTypeError('not_a_promise', [this]);
+      throw MakeTypeError(kNotAPromise, this);
     case 0:  // Pending
       GET_PRIVATE(this, promiseOnResolve).push(onResolve, deferred);
       GET_PRIVATE(this, promiseOnReject).push(onReject, deferred);
       break;
     case +1:  // Resolved
       PromiseEnqueue(GET_PRIVATE(this, promiseValue),
                      [onResolve, deferred],
                      +1);
       break;
     case -1:  // Rejected
@@ skipping 27 matching lines @@
   onReject = IS_SPEC_FUNCTION(onReject) ? onReject
                                         : PromiseIdRejectHandler;
   var that = this;
   var constructor = this.constructor;
   return %_CallFunction(
     this,
     function(x) {
       x = PromiseCoerce(constructor, x);
       if (x === that) {
         DEBUG_PREPARE_STEP_IN_IF_STEPPING(onReject);
-        return onReject(MakeTypeError('promise_cyclic', [x]));
+        return onReject(MakeTypeError(kPromiseCyclic, x));
       } else if (IsPromise(x)) {
         return x.then(onResolve, onReject);
       } else {
         DEBUG_PREPARE_STEP_IN_IF_STEPPING(onResolve);
         return onResolve(x);
       }
     },
     onReject,
     PromiseChain
   );
@@ skipping 99 matching lines @@
 $promiseResolve = PromiseResolve;
 $promiseReject = PromiseReject;
 $promiseChain = PromiseChain;
 $promiseCatch = PromiseCatch;
 $promiseThen = PromiseThen;
 $promiseHasUserDefinedRejectHandler = PromiseHasUserDefinedRejectHandler;
 $promiseStatus = promiseStatus;
 $promiseValue = promiseValue;
 
 })();