Move family of MakeError functions to C++

src/js/regexp.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.
 
 (function(global, utils) {
 
 %CheckIsBootstrapping();
 
 // -------------------------------------------------------------------
 // Imports
 
 var ExpandReplacement;
 var GlobalArray = global.Array;
 var GlobalObject = global.Object;
 var GlobalRegExp = global.RegExp;
 var GlobalRegExpPrototype;
 var InternalArray = utils.InternalArray;
 var InternalPackedArray = utils.InternalPackedArray;
-var MakeTypeError;
 var MaxSimple;
 var MinSimple;
 var matchSymbol = utils.ImportNow("match_symbol");
 var replaceSymbol = utils.ImportNow("replace_symbol");
 var searchSymbol = utils.ImportNow("search_symbol");
 var speciesSymbol = utils.ImportNow("species_symbol");
 var splitSymbol = utils.ImportNow("split_symbol");
 var SpeciesConstructor;
 
 utils.Import(function(from) {
   ExpandReplacement = from.ExpandReplacement;
-  MakeTypeError = from.MakeTypeError;
   MaxSimple = from.MaxSimple;
   MinSimple = from.MinSimple;
   SpeciesConstructor = from.SpeciesConstructor;
 });
 
 // -------------------------------------------------------------------
 
 // Property of the builtins object for recording the result of the last
 // regexp match.  The property RegExpLastMatchInfo includes the matchIndices
 // array of the last successful regexp match (an array of start/end index
@@ skipping 65 matching lines @@
   }
 
   var object = %_NewObject(GlobalRegExp, newtarget);
   return RegExpInitialize(object, pattern, flags);
 }
 
 
 // ES#sec-regexp.prototype.compile RegExp.prototype.compile (pattern, flags)
 function RegExpCompileJS(pattern, flags) {
   if (!IS_REGEXP(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         "RegExp.prototype.compile", this);
   }
 
   if (IS_REGEXP(pattern)) {
-    if (!IS_UNDEFINED(flags)) throw MakeTypeError(kRegExpFlags);
+    if (!IS_UNDEFINED(flags)) throw %make_type_error(kRegExpFlags);
 
     flags = PatternFlags(pattern);
     pattern = REGEXP_SOURCE(pattern);
   }
 
   RegExpInitialize(this, pattern, flags);
 
   // Return undefined for compatibility with JSC.
   // See http://crbug.com/585775 for web compat details.
 }
@@ skipping 40 matching lines @@
   }
   regexp.lastIndex = 0;
   return null;
 }
 
 
 // ES#sec-regexp.prototype.exec
 // RegExp.prototype.exec ( string )
 function RegExpSubclassExecJS(string) {
   if (!IS_REGEXP(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         'RegExp.prototype.exec', this);
   }
 
   string = TO_STRING(string);
   var lastIndex = this.lastIndex;
 
   // Conversion is required by the ES2015 specification (RegExpBuiltinExec
   // algorithm, step 4) even if the value is discarded for non-global RegExps.
   var i = TO_LENGTH(lastIndex);
 
@@ skipping 25 matching lines @@
     this.lastIndex = RegExpLastMatchInfo[CAPTURE1];
   }
   RETURN_NEW_RESULT_FROM_MATCH_INFO(matchIndices, string);
 }
 %FunctionRemovePrototype(RegExpSubclassExecJS);
 
 
 // Legacy implementation of RegExp.prototype.exec
 function RegExpExecJS(string) {
   if (!IS_REGEXP(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         'RegExp.prototype.exec', this);
   }
 
   string = TO_STRING(string);
   var lastIndex = this.lastIndex;
 
   // Conversion is required by the ES2015 specification (RegExpBuiltinExec
   // algorithm, step 4) even if the value is discarded for non-global RegExps.
   var i = TO_LENGTH(lastIndex);
 
@@ skipping 26 matching lines @@
 // ES#sec-regexpexec Runtime Semantics: RegExpExec ( R, S )
 // Also takes an optional exec method in case our caller
 // has already fetched exec.
 function RegExpSubclassExec(regexp, string, exec) {
   if (IS_UNDEFINED(exec)) {
     exec = regexp.exec;
   }
   if (IS_CALLABLE(exec)) {
     var result = %_Call(exec, regexp, string);
     if (!IS_RECEIVER(result) && !IS_NULL(result)) {
-      throw MakeTypeError(kInvalidRegExpExecResult);
+      throw %make_type_error(kInvalidRegExpExecResult);
     }
     return result;
   }
   return %_Call(RegExpExecJS, regexp, string);
 }
 %SetForceInlineFlag(RegExpSubclassExec);
 
 
 // One-element cache for the simplified test regexp.
 var regexp_key;
 var regexp_val;
 
 // Legacy implementation of RegExp.prototype.test
 // Section 15.10.6.3 doesn't actually make sense, but the intention seems to be
 // that test is defined in terms of String.prototype.exec. However, it probably
 // means the original value of String.prototype.exec, which is what everybody
 // else implements.
 function RegExpTest(string) {
   if (!IS_REGEXP(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         'RegExp.prototype.test', this);
   }
   string = TO_STRING(string);
 
   var lastIndex = this.lastIndex;
 
   // Conversion is required by the ES2015 specification (RegExpBuiltinExec
   // algorithm, step 4) even if the value is discarded for non-global RegExps.
   var i = TO_LENGTH(lastIndex);
 
@@ skipping 30 matching lines @@
       return false;
     }
     return true;
   }
 }
 
 
 // ES#sec-regexp.prototype.test RegExp.prototype.test ( S )
 function RegExpSubclassTest(string) {
   if (!IS_RECEIVER(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         'RegExp.prototype.test', this);
   }
   string = TO_STRING(string);
   var match = RegExpSubclassExec(this, string);
   return !IS_NULL(match);
 }
 %FunctionRemovePrototype(RegExpSubclassTest);
 
 function TrimRegExp(regexp) {
   if (regexp_key !== regexp) {
     regexp_key = regexp;
     regexp_val =
       new GlobalRegExp(
           %_SubString(REGEXP_SOURCE(regexp), 2, REGEXP_SOURCE(regexp).length),
           (REGEXP_IGNORE_CASE(regexp) ? REGEXP_MULTILINE(regexp) ? "im" : "i"
                                       : REGEXP_MULTILINE(regexp) ? "m" : ""));
   }
   return regexp_val;
 }
 
 
 function RegExpToString() {
   if (!IS_RECEIVER(this)) {
-    throw MakeTypeError(
+    throw %make_type_error(
         kIncompatibleMethodReceiver, 'RegExp.prototype.toString', this);
   }
   if (this === GlobalRegExpPrototype) {
     %IncrementUseCounter(kRegExpPrototypeToString);
   }
   return '/' + TO_STRING(this.source) + '/' + TO_STRING(this.flags);
 }
 
 
 function AtSurrogatePair(subject, index) {
   if (index + 1 >= subject.length) return false;
   var first = %_StringCharCodeAt(subject, index);
   if (first < 0xD800 || first > 0xDBFF) return false;
   var second = %_StringCharCodeAt(subject, index + 1);
   return second >= 0xDC00 || second <= 0xDFFF;
 }
 
 
 // Legacy implementation of RegExp.prototype[Symbol.split] which
 // doesn't properly call the underlying exec, @@species methods
 function RegExpSplit(string, limit) {
   // TODO(yangguo): allow non-regexp receivers.
   if (!IS_REGEXP(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         "RegExp.prototype.@@split", this);
   }
   var separator = this;
   var subject = TO_STRING(string);
 
   limit = (IS_UNDEFINED(limit)) ? kMaxUint32 : TO_UINT32(limit);
   var length = subject.length;
 
   if (limit === 0) return [];
 
@@ skipping 53 matching lines @@
   var array_result = [];
   %MoveArrayContents(result, array_result);
   return array_result;
 }
 
 
 // ES#sec-regexp.prototype-@@split
 // RegExp.prototype [ @@split ] ( string, limit )
 function RegExpSubclassSplit(string, limit) {
   if (!IS_RECEIVER(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         "RegExp.prototype.@@split", this);
   }
   string = TO_STRING(string);
   var constructor = SpeciesConstructor(this, GlobalRegExp);
   var flags = TO_STRING(this.flags);
 
   // TODO(adamk): this fast path is wrong with respect to this.global
   // and this.sticky, but hopefully the spec will remove those gets
   // and thus make the assumption of 'exec' having no side-effects
   // more correct. Also, we doesn't ensure that 'exec' is actually
@@ skipping 55 matching lines @@
                      %_SubString(string, prevStringIndex, size));
   return array;
 }
 %FunctionRemovePrototype(RegExpSubclassSplit);
 
 
 // ES#sec-regexp.prototype-@@match
 // RegExp.prototype [ @@match ] ( string )
 function RegExpSubclassMatch(string) {
   if (!IS_RECEIVER(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         "RegExp.prototype.@@match", this);
   }
   string = TO_STRING(string);
   var global = this.global;
   if (!global) return RegExpSubclassExec(this, string);
   var unicode = this.unicode;
   this.lastIndex = 0;
   var array = new InternalArray();
   var n = 0;
   var result;
@@ skipping 137 matching lines @@
 
   result += replacement;  // The add method converts to string if necessary.
   // Can't use matchInfo any more from here, since the function could
   // overwrite it.
   return result + %_SubString(subject, endOfMatch, subject.length);
 }
 
 
 function RegExpReplace(string, replace) {
   if (!IS_REGEXP(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         "RegExp.prototype.@@replace", this);
   }
   var subject = TO_STRING(string);
   var search = this;
 
   if (!IS_CALLABLE(replace)) {
     replace = TO_STRING(replace);
 
     if (!REGEXP_GLOBAL(search)) {
       // Non-global regexp search, string replace.
@@ skipping 135 matching lines @@
   var lastIndex = regexp.lastIndex;
   regexp.lastIndex = lastIndex +
                      AdvanceStringIndex(string, lastIndex, unicode);
 }
 
 
 // ES#sec-regexp.prototype-@@replace
 // RegExp.prototype [ @@replace ] ( string, replaceValue )
 function RegExpSubclassReplace(string, replace) {
   if (!IS_RECEIVER(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         "RegExp.prototype.@@replace", this);
   }
   string = TO_STRING(string);
   var length = string.length;
   var functionalReplace = IS_CALLABLE(replace);
   if (!functionalReplace) replace = TO_STRING(replace);
   var global = TO_BOOLEAN(this.global);
   if (global) {
     var unicode = TO_BOOLEAN(this.unicode);
     this.lastIndex = 0;
@@ skipping 64 matching lines @@
   if (nextSourcePosition >= length) return accumulatedResult;
   return accumulatedResult + %_SubString(string, nextSourcePosition, length);
 }
 %FunctionRemovePrototype(RegExpSubclassReplace);
 
 
 // ES#sec-regexp.prototype-@@search
 // RegExp.prototype [ @@search ] ( string )
 function RegExpSubclassSearch(string) {
   if (!IS_RECEIVER(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         "RegExp.prototype.@@search", this);
   }
   string = TO_STRING(string);
   var previousLastIndex = this.lastIndex;
   this.lastIndex = 0;
   var result = RegExpSubclassExec(this, string);
   this.lastIndex = previousLastIndex;
   if (IS_NULL(result)) return -1;
   return result.index;
 }
@@ skipping 57 matching lines @@
     var matchEnd = RegExpLastMatchInfo[CAPTURE(index + 1)];
     if (matchStart == -1 || matchEnd == -1) return '';
     return %_SubString(LAST_SUBJECT(RegExpLastMatchInfo), matchStart, matchEnd);
   };
 }
 
 
 // ES6 21.2.5.3.
 function RegExpGetFlags() {
   if (!IS_RECEIVER(this)) {
-    throw MakeTypeError(
+    throw %make_type_error(
         kRegExpNonObject, "RegExp.prototype.flags", TO_STRING(this));
   }
   var result = '';
   if (this.global) result += 'g';
   if (this.ignoreCase) result += 'i';
   if (this.multiline) result += 'm';
   if (this.unicode) result += 'u';
   if (this.sticky) result += 'y';
   return result;
 }
 
 
 // ES6 21.2.5.4.
 function RegExpGetGlobal() {
   if (!IS_REGEXP(this)) {
     // TODO(littledan): Remove this RegExp compat workaround
     if (this === GlobalRegExpPrototype) {
       %IncrementUseCounter(kRegExpPrototypeOldFlagGetter);
       return UNDEFINED;
     }
-    throw MakeTypeError(kRegExpNonRegExp, "RegExp.prototype.global");
+    throw %make_type_error(kRegExpNonRegExp, "RegExp.prototype.global");
   }
   return TO_BOOLEAN(REGEXP_GLOBAL(this));
 }
 %SetForceInlineFlag(RegExpGetGlobal);
 
 
 // ES6 21.2.5.5.
 function RegExpGetIgnoreCase() {
   if (!IS_REGEXP(this)) {
     // TODO(littledan): Remove this RegExp compat workaround
     if (this === GlobalRegExpPrototype) {
       %IncrementUseCounter(kRegExpPrototypeOldFlagGetter);
       return UNDEFINED;
     }
-    throw MakeTypeError(kRegExpNonRegExp, "RegExp.prototype.ignoreCase");
+    throw %make_type_error(kRegExpNonRegExp, "RegExp.prototype.ignoreCase");
   }
   return TO_BOOLEAN(REGEXP_IGNORE_CASE(this));
 }
 
 
 // ES6 21.2.5.7.
 function RegExpGetMultiline() {
   if (!IS_REGEXP(this)) {
     // TODO(littledan): Remove this RegExp compat workaround
     if (this === GlobalRegExpPrototype) {
       %IncrementUseCounter(kRegExpPrototypeOldFlagGetter);
       return UNDEFINED;
     }
-    throw MakeTypeError(kRegExpNonRegExp, "RegExp.prototype.multiline");
+    throw %make_type_error(kRegExpNonRegExp, "RegExp.prototype.multiline");
   }
   return TO_BOOLEAN(REGEXP_MULTILINE(this));
 }
 
 
 // ES6 21.2.5.10.
 function RegExpGetSource() {
   if (!IS_REGEXP(this)) {
     // TODO(littledan): Remove this RegExp compat workaround
     if (this === GlobalRegExpPrototype) {
       %IncrementUseCounter(kRegExpPrototypeSourceGetter);
       return "(?:)";
     }
-    throw MakeTypeError(kRegExpNonRegExp, "RegExp.prototype.source");
+    throw %make_type_error(kRegExpNonRegExp, "RegExp.prototype.source");
   }
   return REGEXP_SOURCE(this);
 }
 
 
 // ES6 21.2.5.12.
 function RegExpGetSticky() {
   if (!IS_REGEXP(this)) {
     // Compat fix: RegExp.prototype.sticky == undefined; UseCounter tracks it
     // TODO(littledan): Remove this workaround or standardize it
     if (this === GlobalRegExpPrototype) {
       %IncrementUseCounter(kRegExpPrototypeStickyGetter);
       return UNDEFINED;
     }
-    throw MakeTypeError(kRegExpNonRegExp, "RegExp.prototype.sticky");
+    throw %make_type_error(kRegExpNonRegExp, "RegExp.prototype.sticky");
   }
   return TO_BOOLEAN(REGEXP_STICKY(this));
 }
 %SetForceInlineFlag(RegExpGetSticky);
 
 
 // ES6 21.2.5.15.
 function RegExpGetUnicode() {
   if (!IS_REGEXP(this)) {
     // TODO(littledan): Remove this RegExp compat workaround
     if (this === GlobalRegExpPrototype) {
       %IncrementUseCounter(kRegExpPrototypeUnicodeGetter);
       return UNDEFINED;
     }
-    throw MakeTypeError(kRegExpNonRegExp, "RegExp.prototype.unicode");
+    throw %make_type_error(kRegExpNonRegExp, "RegExp.prototype.unicode");
   }
   return TO_BOOLEAN(REGEXP_UNICODE(this));
 }
 %SetForceInlineFlag(RegExpGetUnicode);
 
 
 function RegExpSpecies() {
   return this;
 }
 
@@ skipping 98 matching lines @@
   to.InternalRegExpMatch = InternalRegExpMatch;
   to.InternalRegExpReplace = InternalRegExpReplace;
   to.IsRegExp = IsRegExp;
   to.RegExpExec = DoRegExpExec;
   to.RegExpInitialize = RegExpInitialize;
   to.RegExpLastMatchInfo = RegExpLastMatchInfo;
   to.RegExpTest = RegExpTest;
 });
 
 })