[regexp] Named capture support for callable replacements

test/mjsunit/harmony/regexp-named-captures.js

 // Copyright 2015 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.
 
 // Flags: --harmony-regexp-named-captures
 
 // Malformed named captures.
 assertThrows("/(?<>a)/u");  // Empty name.
 assertThrows("/(?<aa)/u");  // Unterminated name.
 assertThrows("/(?<42a>a)/u");  // Name starting with digits.
@@ skipping 78 matching lines @@
 assertEquals("a", /(?<$𐒤>a)/u.exec("bab").groups.$𐒤);
 assertEquals("a", /(?<_\u200C>a)/u.exec("bab").groups._\u200C);
 assertEquals("a", /(?<_\u200D>a)/u.exec("bab").groups._\u200D);
 assertEquals("a", /(?<ಠ_ಠ>a)/u.exec("bab").groups.ಠ_ಠ);
 assertThrows('/(?<❤>a)/u', SyntaxError);
 assertThrows('/(?<𐒤>a)/u', SyntaxError);  // ID_Continue but not ID_Start.
 
 // The '__proto__' property on the groups object.
 assertEquals(undefined, /(?<a>.)/u.exec("a").groups.__proto__);
 assertEquals("a", /(?<__proto__>a)/u.exec("a").groups.__proto__);
+
+// @@replace with a callable replacement argument (no named captures).
+{
+  let result = "abcd".replace(/(.)(.)/u, (match, fst, snd, offset, str) => {
+    assertEquals("ab", match);
+    assertEquals("a", fst);
+    assertEquals("b", snd);
+    assertEquals(0, offset);
+    assertEquals("abcd", str);
+    return `${snd}${fst}`;
+  });
+  assertEquals("bacd", result);
+}
+
+// @@replace with a callable replacement argument (global, named captures).
+{
+  let i = 0;
+  let result = "abcd".replace(/(?<fst>.)(?<snd>.)/gu,
+      (match, fst, snd, groups, offset, str) => {
+    if (i == 0) {
+      assertEquals("ab", match);
+      assertEquals("a", groups.fst);
+      assertEquals("b", groups.snd);
+      assertEquals("a", fst);
+      assertEquals("b", snd);
+      assertEquals(0, offset);
+      assertEquals("abcd", str);
+    } else if (i == 1) {
+      assertEquals("cd", match);
+      assertEquals("c", groups.fst);
+      assertEquals("d", groups.snd);
+      assertEquals("c", fst);
+      assertEquals("d", snd);
+      assertEquals(2, offset);
+      assertEquals("abcd", str);
+    } else {
+      assertUnreachable();
+    }
+    i++;
+    return `${groups.snd}${groups.fst}`;
+  });
+  assertEquals("badc", result);
+}
+
+// @@replace with a callable replacement argument (non-global, named captures).
+{
+  let result = "abcd".replace(/(?<fst>.)(?<snd>.)/u,
+      (match, fst, snd, groups, offset, str) => {
+    assertEquals("ab", match);
+    assertEquals("a", groups.fst);
+    assertEquals("b", groups.snd);
+    assertEquals("a", fst);
+    assertEquals("b", snd);
+    assertEquals(0, offset);
+    assertEquals("abcd", str);
+    return `${groups.snd}${groups.fst}`;
+  });
+  assertEquals("bacd", result);
+}
+
+function toSlowMode(re) {
+  re.exec = (str) => RegExp.prototype.exec.call(re, str);
+  return re;
+}
+
+// @@replace with a callable replacement argument (slow, global,
+// named captures).
+{
+  let i = 0;
+  let re = toSlowMode(/(?<fst>.)(?<snd>.)/gu);
+  let result = "abcd".replace(re, (match, fst, snd, groups, offset, str) => {
+    if (i == 0) {
+      assertEquals("ab", match);
+      assertEquals("a", groups.fst);
+      assertEquals("b", groups.snd);
+      assertEquals("a", fst);
+      assertEquals("b", snd);
+      assertEquals(0, offset);
+      assertEquals("abcd", str);
+    } else if (i == 1) {
+      assertEquals("cd", match);
+      assertEquals("c", groups.fst);
+      assertEquals("d", groups.snd);
+      assertEquals("c", fst);
+      assertEquals("d", snd);
+      assertEquals(2, offset);
+      assertEquals("abcd", str);
+    } else {
+      assertUnreachable();
+    }
+    i++;
+    return `${groups.snd}${groups.fst}`;
+  });
+  assertEquals("badc", result);
+}
+
+// @@replace with a callable replacement argument (slow, non-global,
+// named captures).
+{
+  let re = toSlowMode(/(?<fst>.)(?<snd>.)/u);
+  let result = "abcd".replace(re, (match, fst, snd, groups, offset, str) => {
+    assertEquals("ab", match);
+    assertEquals("a", groups.fst);
+    assertEquals("b", groups.snd);
+    assertEquals("a", fst);
+    assertEquals("b", snd);
+    assertEquals(0, offset);
+    assertEquals("abcd", str);
+    return `${groups.snd}${groups.fst}`;
+  });
+  assertEquals("bacd", result);
+}

[Yang, 2017/03/23 14:58:22]

Not directly related to this CL. Could we have some tests for interactions with

- lookbehind assertions
- nested groups
- number for group names

[jgruber, 2017/03/24 14:06:46]

Acknowledged.