[regexp] Experimental support for regexp named captures

src/runtime/runtime-regexp.cc

 // Copyright 2014 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/runtime/runtime-utils.h"
 
 #include "src/arguments.h"
 #include "src/conversions-inl.h"
 #include "src/isolate-inl.h"
 #include "src/messages.h"
@@ skipping 779 matching lines @@
 }
 
 
 RUNTIME_FUNCTION(Runtime_RegExpSource) {
   SealHandleScope shs(isolate);
   DCHECK(args.length() == 1);
   CONVERT_ARG_CHECKED(JSRegExp, regexp, 0);
   return regexp->source();
 }
 
-
 RUNTIME_FUNCTION(Runtime_RegExpConstructResult) {
   HandleScope handle_scope(isolate);
   DCHECK(args.length() == 3);
   CONVERT_SMI_ARG_CHECKED(size, 0);
   CHECK(size >= 0 && size <= FixedArray::kMaxLength);
   CONVERT_ARG_HANDLE_CHECKED(Object, index, 1);
   CONVERT_ARG_HANDLE_CHECKED(Object, input, 2);
   Handle<FixedArray> elements = isolate->factory()->NewFixedArray(size);
   Handle<Map> regexp_map(isolate->native_context()->regexp_result_map());
   Handle<JSObject> object =
@@ skipping 196 matching lines @@
 
 
 RUNTIME_FUNCTION(Runtime_RegExpExecReThrow) {
   SealHandleScope shs(isolate);
   DCHECK(args.length() == 4);
   Object* exception = isolate->pending_exception();
   isolate->clear_pending_exception();
   return isolate->ReThrow(exception);
 }
 
+RUNTIME_FUNCTION(Runtime_RegExpResultAttachNamedCaptures) {
+  HandleScope handle_scope(isolate);
+  DCHECK(args.length() == 2);
+  CONVERT_ARG_CHECKED(JSArray, result, 0);
+  CONVERT_ARG_CHECKED(JSRegExp, regexp, 1);
+
+  if (regexp->TypeTag() != JSRegExp::IRREGEXP ||

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

We don't actually have to check this, right? We can assert this in the
then-block, but for non-IRREGEXP the capture name map should not be a fixed
array anyways.

[jgruber, 2016/06/13 13:10:00]

I think we need to check, as ATOM JSRegExps have a shorter data array (see
Factory::SetRegExpAtomData) and we'd have an out of bounds access.

+      !regexp->DataAt(JSRegExp::kIrregexpCaptureNameMapIndex)->IsFixedArray())

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

Please add brackets around the then-block.

[jgruber, 2016/06/13 13:10:00]

Done.

+    return isolate->heap()->undefined_value();
+
+  FixedArray* captures =
+      FixedArray::cast(regexp->DataAt(JSRegExp::kIrregexpCaptureNameMapIndex));
+  DCHECK(captures->length() > 0);
+
+  Handle<JSArray> result_handle = handle(result, isolate);
+
+  for (int i = 0; i < captures->length(); i += 2) {
+    Handle<String> name = handle(String::cast(captures->get(i)), isolate);
+    const int ix = Smi::cast(captures->get(i + 1))->value();

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

Accessing captures like this is not GC-safe. You need to put captures into a
handle.

[jgruber, 2016/06/13 13:10:00]

Done.

+
+    MaybeHandle<Object> existing = Object::GetProperty(result_handle, name);
+    if (!existing.ToHandleChecked()->IsUndefined()) {
+      continue;  // Skip conflicts.

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

I don't think this can actually happen unless the property is on the array
prototype. Let's not care about that and just always add the property. We can
still change this once the spec takes shape.

[jgruber, 2016/06/13 13:10:00]

This happens for regexp properties 'index' and 'input'. There's two test cases
covering this. If we remove this check, those properties could be overwritten.

[Yang, 2016/06/13 13:38:00]

I see. Can we use JSReceiver::HasOwnProperty for this?

[jgruber, 2016/06/14 07:53:12]

Sounds good, will change this when we look at adding properties for named
captures.

+    }
+
+    Handle<Object> value =
+        Object::GetElement(isolate, result_handle, ix).ToHandleChecked();
+    JSObject::AddProperty(result_handle, name, value, NONE);
+  }
+
+  return isolate->heap()->undefined_value();
+}
 
 RUNTIME_FUNCTION(Runtime_IsRegExp) {
   SealHandleScope shs(isolate);
   DCHECK(args.length() == 1);
   CONVERT_ARG_CHECKED(Object, obj, 0);
   return isolate->heap()->ToBoolean(obj->IsJSRegExp());
 }
 }  // namespace internal
 }  // namespace v8