[regexp] Named capture support for string replacements

src/objects.cc

 // 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.
 
 #include "src/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <memory>
 #include <sstream>
@@ skipping 11385 matching lines @@
     return SearchString<const uint8_t>(isolate, receiver_content, pat_vector,
                                        start_index);
   }
   Vector<const uc16> pat_vector = search_content.ToUC16Vector();
   return SearchString<const uc16>(isolate, receiver_content, pat_vector,
                                   start_index);
 }
 
 MaybeHandle<String> String::GetSubstitution(Isolate* isolate, Match* match,
                                             Handle<String> replacement) {
+  DCHECK_IMPLIES(match->HasNamedCaptures(), FLAG_harmony_regexp_named_captures);
+
   Factory* factory = isolate->factory();
 
   const int replacement_length = replacement->length();
   const int captures_length = match->CaptureCount();
 
   replacement = String::Flatten(replacement);
 
   Handle<String> dollar_string =
       factory->LookupSingleCharacterStringFromCode('$');
   int next_dollar_ix = String::IndexOf(isolate, replacement, dollar_string, 0);
@@ skipping 66 matching lines @@
 
         bool capture_exists;
         Handle<String> capture;
         ASSIGN_RETURN_ON_EXCEPTION(
             isolate, capture, match->GetCapture(scaled_index, &capture_exists),
             String);
         if (capture_exists) builder.AppendString(capture);
         continue_from_ix = peek_ix + advance;
         break;
       }
+      case '<': {  // $<name> - named capture
+        if (!match->HasNamedCaptures()) {
+          builder.AppendCharacter('$');
+          continue_from_ix = peek_ix;
+          break;
+        }
+
+        Handle<String> bracket_string =
+            factory->LookupSingleCharacterStringFromCode('>');
+        const int closing_bracket_ix =
+            String::IndexOf(isolate, replacement, bracket_string, peek_ix + 1);
+
+        if (closing_bracket_ix == -1) {
+          THROW_NEW_ERROR(
+              isolate,
+              NewSyntaxError(MessageTemplate::kRegExpInvalidReplaceString,
+                             replacement),
+              String);
+        }
+
+        Handle<String> capture_name =
+            factory->NewSubString(replacement, peek_ix + 1, closing_bracket_ix);
+        bool capture_exists;
+        Handle<String> capture;
+        ASSIGN_RETURN_ON_EXCEPTION(
+            isolate, capture,
+            match->GetNamedCapture(capture_name, &capture_exists), String);
+        if (capture_exists) builder.AppendString(capture);
+        continue_from_ix = closing_bracket_ix + 1;
+        break;
+      }
       default:
         builder.AppendCharacter('$');
         continue_from_ix = peek_ix;
         break;
     }
 
     // Go the the next $ in the replacement.
     // TODO(jgruber): Single-char lookups could be much more efficient.
     DCHECK_NE(continue_from_ix, -1);
     next_dollar_ix =
@@ skipping 150 matching lines @@
       if (Get(i) != unibrow::Utf16::TrailSurrogate(r)) return false;
     } else {
       if (Get(i) != r) return false;
     }
     utf8_data += cursor;
     remaining_in_str -= cursor;
   }
   return (allow_prefix_match || i == slen) && remaining_in_str == 0;
 }
 
+template <>
+bool String::IsEqualTo(Vector<const uint8_t> str) {
+  return IsOneByteEqualTo(str);
+}
+
+template <>
+bool String::IsEqualTo(Vector<const uc16> str) {
+  return IsTwoByteEqualTo(str);
+}
 
 bool String::IsOneByteEqualTo(Vector<const uint8_t> str) {
   int slen = length();
   if (str.length() != slen) return false;
   DisallowHeapAllocation no_gc;
   FlatContent content = GetFlatContent();
   if (content.IsOneByte()) {
     return CompareChars(content.ToOneByteVector().start(),
                         str.start(), slen) == 0;
   }
@@ skipping 8644 matching lines @@
       // depend on this.
       return DICTIONARY_ELEMENTS;
     }
     DCHECK_LE(kind, LAST_ELEMENTS_KIND);
     return kind;
   }
 }
 
 }  // namespace internal
 }  // namespace v8