[regexp] Experimental support for regexp named captures

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 123 matching lines @@
 
 
 function DoRegExpExec(regexp, string, index) {
   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)
+macro RETURN_NEW_RESULT_FROM_MATCH_INFO(MATCHINFO, STRING, JSREGEXP)
   var numResults = NUMBER_OF_CAPTURES(MATCHINFO) >> 1;
   var start = MATCHINFO[CAPTURE0];
   var end = MATCHINFO[CAPTURE1];
   // Calculate the substring of the first match before creating the result array
   // to avoid an unnecessary write barrier storing the first result.
   var first = %_SubString(STRING, start, end);
   var result = %_RegExpConstructResult(numResults, start, STRING);
   result[0] = first;
   if (numResults == 1) return result;
   var j = REGEXP_FIRST_CAPTURE + 2;
   for (var i = 1; i < numResults; i++) {
     start = MATCHINFO[j++];
     if (start != -1) {
       end = MATCHINFO[j];
       result[i] = %_SubString(STRING, start, end);
     }
     j++;
   }
+  // For each named capture 'a', create a property result.a containing the
+  // corresponding captured string.
+  %RegExpResultAttachNamedCaptures(result, JSREGEXP);

[Yang, 2016/06/13 10:54:52]

This is going to be fairly expensive, and affects every regexp, even ones that
has no named captures. I'm pretty sure this affects the Octane benchmark score,
especially the regexp benchmark.

We need a more efficient way to check whether the regexp has named captures at
all, and only go into runtime if we do.

I can think of a few alternatives, in descending order of what I think is best.
- We implement this whole macro as turbofan stub. That's going to be fairly
involved.
- We check for kIrregexpCaptureNameMapIndex in regexp data in the generated code
of %_RegExpConstructResult and call into %RegExpResultAttachNamedCaptures from
there if necessary.
- We use a hidden property using a private symbol as key to store whether we
have named captures on the regexp. Loading from a property should be a lot
cheaper thanks to inline caching and optimizations in optimized code. We could
even store the fixed array for the property names there.
- We change the RegExpExecStub to encode another element in MATCHINFO to
indicate whether there is a named capture.
- We can add another bit to regexp flags so that we can check upfront using
%_RegExpFlags (see macros.py, REGEXP_GLOBAL). This is somewhat hacky, but easier
to implement.

How about we first land the rest of the CL without storing named properties to
the result object?

[jgruber, 2016/06/13 13:09:59]

I'm tending towards this as an initial approach. This would mean passing the
JSRegExp into %_RegExpConstructResult for accessing the capture map though.
Sounds good.

   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);
   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);
+    RETURN_NEW_RESULT_FROM_MATCH_INFO(matchInfo, string, regexp);
   }
   regexp.lastIndex = 0;
   return null;
 }
 
 
 // ES#sec-regexp.prototype.exec
 // RegExp.prototype.exec ( string )
 function RegExpSubclassExecJS(string) {
   if (!IS_REGEXP(this)) {
@@ skipping 28 matching lines @@
 
   if (IS_NULL(matchIndices)) {
     this.lastIndex = 0;
     return null;
   }
 
   // Successful match.
   if (updateLastIndex) {
     this.lastIndex = RegExpLastMatchInfo[CAPTURE1];
   }
-  RETURN_NEW_RESULT_FROM_MATCH_INFO(matchIndices, string);
+  RETURN_NEW_RESULT_FROM_MATCH_INFO(matchIndices, string, this);
 }
 %FunctionRemovePrototype(RegExpSubclassExecJS);
 
 
 // Legacy implementation of RegExp.prototype.exec
 function RegExpExecJS(string) {
   if (!IS_REGEXP(this)) {
     throw MakeTypeError(kIncompatibleMethodReceiver,
                         'RegExp.prototype.exec', this);
   }
@@ skipping 20 matching lines @@
 
   if (IS_NULL(matchIndices)) {
     this.lastIndex = 0;
     return null;
   }
 
   // Successful match.
   if (updateLastIndex) {
     this.lastIndex = RegExpLastMatchInfo[CAPTURE1];
   }
-  RETURN_NEW_RESULT_FROM_MATCH_INFO(matchIndices, string);
+  RETURN_NEW_RESULT_FROM_MATCH_INFO(matchIndices, string, this);
 }
 
 
 // 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;
   }
@@ skipping 933 matching lines @@
 %ToFastProperties(GlobalRegExp);
 
 // -------------------------------------------------------------------
 // Internal
 
 var InternalRegExpMatchInfo = new InternalPackedArray(2, "", UNDEFINED, 0, 0);
 
 function InternalRegExpMatch(regexp, subject) {
   var matchInfo = %_RegExpExec(regexp, subject, 0, InternalRegExpMatchInfo);
   if (!IS_NULL(matchInfo)) {
-    RETURN_NEW_RESULT_FROM_MATCH_INFO(matchInfo, subject);
+    RETURN_NEW_RESULT_FROM_MATCH_INFO(matchInfo, subject, regexp);
   }
   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.RegExpInitialize = RegExpInitialize;
   to.RegExpLastMatchInfo = RegExpLastMatchInfo;
   to.RegExpSubclassExecJS = RegExpSubclassExecJS;
   to.RegExpSubclassMatch = RegExpSubclassMatch;
   to.RegExpSubclassReplace = RegExpSubclassReplace;
   to.RegExpSubclassSearch = RegExpSubclassSearch;
   to.RegExpSubclassSplit = RegExpSubclassSplit;
   to.RegExpSubclassTest = RegExpSubclassTest;
   to.RegExpTest = RegExpTest;
 });
 
 })