[regexp, intl] Intl should not cause side effects to the RegExp object.

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) {
 
 'use strict';
 
 %CheckIsBootstrapping();
 
@@ skipping 104 matching lines @@
   }
 
   RegExpInitialize(this, pattern, flags);
 
   // Return undefined for compatibility with JSC.
   // See http://crbug.com/585775 for web compat details.
 }
 
 
 function DoRegExpExec(regexp, string, index) {
-  return %_RegExpExec(regexp, string, index, RegExpLastMatchInfo);

[Dan Ehrenberg, 2016/03/23 15:55:41]

Why this change? Will it have performance implications?

[Yang, 2016/03/24 06:14:13]

Thanks for catching this. I changed it for easier debugging, but then forgot to
revert.

+  return %RegExpExec(regexp, string, index, RegExpLastMatchInfo);
 }
 
 
 // This is kind of performance sensitive, so we want to avoid unnecessary
 // type checks on inputs. But we also don't want to inline it several times
 // manually, so we use a macro :-)
 macro RETURN_NEW_RESULT_FROM_MATCH_INFO(MATCHINFO, STRING)
   var numResults = NUMBER_OF_CAPTURES(MATCHINFO) >> 1;
   var start = MATCHINFO[CAPTURE0];
   var end = MATCHINFO[CAPTURE1];
@@ skipping 11 matching lines @@
       result[i] = %_SubString(STRING, start, end);
     }
     j++;
   }
   return result;
 endmacro
 
 
 function RegExpExecNoTests(regexp, string, start) {
   // Must be called with RegExp, string and positive integer as arguments.
-  var matchInfo = %_RegExpExec(regexp, string, start, RegExpLastMatchInfo);
+  var matchInfo = %RegExpExec(regexp, string, start, RegExpLastMatchInfo);
   if (matchInfo !== null) {
     // ES6 21.2.5.2.2 step 18.
     if (REGEXP_STICKY(regexp)) regexp.lastIndex = matchInfo[CAPTURE1];
     RETURN_NEW_RESULT_FROM_MATCH_INFO(matchInfo, string);
   }
   regexp.lastIndex = 0;
   return null;
 }
 
 
@@ skipping 14 matching lines @@
   if (updateLastIndex) {
     if (i < 0 || i > string.length) {
       this.lastIndex = 0;
       return null;
     }
   } else {
     i = 0;
   }
 
   // matchIndices is either null or the RegExpLastMatchInfo array.
-  var matchIndices = %_RegExpExec(this, string, i, RegExpLastMatchInfo);
+  var matchIndices = %RegExpExec(this, string, i, RegExpLastMatchInfo);
 
   if (IS_NULL(matchIndices)) {
     this.lastIndex = 0;
     return null;
   }
 
   // Successful match.
   if (updateLastIndex) {
     this.lastIndex = RegExpLastMatchInfo[CAPTURE1];
   }
@@ skipping 21 matching lines @@
   // 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);
 
   if (REGEXP_GLOBAL(this) || REGEXP_STICKY(this)) {
     if (i < 0 || i > string.length) {
       this.lastIndex = 0;
       return false;
     }
     // matchIndices is either null or the RegExpLastMatchInfo array.
-    var matchIndices = %_RegExpExec(this, string, i, RegExpLastMatchInfo);
+    var matchIndices = %RegExpExec(this, string, i, RegExpLastMatchInfo);
     if (IS_NULL(matchIndices)) {
       this.lastIndex = 0;
       return false;
     }
     this.lastIndex = RegExpLastMatchInfo[CAPTURE1];
     return true;
   } else {
     // Non-global, non-sticky regexp.
     // Remove irrelevant preceeding '.*' in a test regexp.  The expression
     // checks whether this.source starts with '.*' and that the third char is
     // not a '?'.  But see https://code.google.com/p/v8/issues/detail?id=3560
     var regexp = this;
     var source = REGEXP_SOURCE(regexp);
     if (regexp.length >= 3 &&
         %_StringCharCodeAt(regexp, 0) == 46 &&  // '.'
         %_StringCharCodeAt(regexp, 1) == 42 &&  // '*'
         %_StringCharCodeAt(regexp, 2) != 63) {  // '?'
       regexp = TrimRegExp(regexp);
     }
     // matchIndices is either null or the RegExpLastMatchInfo array.
-    var matchIndices = %_RegExpExec(regexp, string, 0, RegExpLastMatchInfo);
+    var matchIndices = %RegExpExec(regexp, string, 0, RegExpLastMatchInfo);
     if (IS_NULL(matchIndices)) {
       this.lastIndex = 0;
       return false;
     }
     return true;
   }
 }
 
 function TrimRegExp(regexp) {
   if (regexp_key !== regexp) {
@@ skipping 502 matching lines @@
 utils.InstallGetterSetter(GlobalRegExp, "$'", RegExpGetRightContext, NoOpSetter,
                           DONT_ENUM | DONT_DELETE);
 
 for (var i = 1; i < 10; ++i) {
   utils.InstallGetterSetter(GlobalRegExp, '$' + i, RegExpMakeCaptureGetter(i),
                             NoOpSetter, DONT_DELETE);
 }
 %ToFastProperties(GlobalRegExp);
 
 // -------------------------------------------------------------------
+// Internal
+
+var InternalRegExpMatchInfo = UNDEFINED;
+
+function InternalRegExpMatch(regexp, subject) {
+  if (IS_UNDEFINED(InternalRegExpMatchInfo)) {
+    InternalRegExpMatchInfo = new InternalPackedArray(2, "", UNDEFINED, 0, 0);
+  }
+  var matchInfo = %RegExpExec(regexp, subject, 0, InternalRegExpMatchInfo);
+  if (!IS_NULL(matchInfo)) {
+    RETURN_NEW_RESULT_FROM_MATCH_INFO(matchInfo, subject);
+  }
+  return null;
+}
+
+function InternalRegExpReplace(regexp, subject, replacement) {
+  return %StringReplaceGlobalRegExpWithString(
+      subject, regexp, replacement, InternalRegExpMatchInfo);
+}
+
+// -------------------------------------------------------------------
 // Exports
 
 utils.Export(function(to) {
+  to.InternalRegExpMatch = InternalRegExpMatch;
+  to.InternalRegExpReplace = InternalRegExpReplace;
+  to.IsRegExp = IsRegExp;
   to.RegExpExec = DoRegExpExec;
   to.RegExpExecNoTests = RegExpExecNoTests;
   to.RegExpLastMatchInfo = RegExpLastMatchInfo;
   to.RegExpTest = RegExpTest;
-  to.IsRegExp = IsRegExp;
 });
 
 })