[regexp] Port RegExp getters and setters

BUG=v8:5339

Review-Url: https://codereview.chromium.org/2305573002
Cr-Commit-Position: refs/heads/master@{#39076}

src/bootstrapper.cc

@@ -365,17 +365,6 @@ void InstallFunction(Handle<JSObject> target, Handle<JSFunction> function,
   InstallFunction(target, name, function, name_string, attributes);
 }
 
-Handle<JSFunction> InstallGetter(Handle<JSObject> target,
-                                 Handle<Name> property_name,
-                                 Handle<JSFunction> getter,
-                                 PropertyAttributes attributes = DONT_ENUM) {
-  Handle<Object> setter = target->GetIsolate()->factory()->undefined_value();
-  JSObject::DefineAccessor(target, property_name, getter, setter, attributes)
-      .Check();
-  getter->shared()->set_native(true);
-  return getter;
-}
-
 Handle<JSFunction> CreateFunction(Isolate* isolate, Handle<String> name,
                                   InstanceType type, int instance_size,
                                   MaybeHandle<JSObject> maybe_prototype,
@@ -461,17 +450,54 @@ Handle<JSFunction> SimpleInstallFunction(Handle<JSObject> base,
   return fun;
 }
 
+void SimpleInstallGetterSetter(Handle<JSObject> base, Handle<String> name,
+                               Builtins::Name call_getter,
+                               Builtins::Name call_setter,
+                               PropertyAttributes attribs) {
+  Isolate* const isolate = base->GetIsolate();
+
+  Handle<String> getter_name =
+      Name::ToFunctionName(name, isolate->factory()->get_string())
+          .ToHandleChecked();
+  Handle<JSFunction> getter =
+      SimpleCreateFunction(isolate, getter_name, call_getter, 0, false);
+  getter->shared()->set_native(true);
+
+  Handle<String> setter_name =
+      Name::ToFunctionName(name, isolate->factory()->set_string())
+          .ToHandleChecked();
+  Handle<JSFunction> setter =
+      SimpleCreateFunction(isolate, setter_name, call_setter, 0, false);
+  setter->shared()->set_native(true);
+
+  JSObject::DefineAccessor(base, name, getter, setter, attribs).Check();
+}
+
 Handle<JSFunction> SimpleInstallGetter(Handle<JSObject> base,
-                                       Handle<String> name, Builtins::Name call,
-                                       bool adapt) {
+                                       Handle<String> name,
+                                       Handle<Name> property_name,
+                                       Builtins::Name call, bool adapt) {
   Isolate* const isolate = base->GetIsolate();
-  Handle<String> fun_name =
+
+  Handle<String> getter_name =
       Name::ToFunctionName(name, isolate->factory()->get_string())
           .ToHandleChecked();
-  Handle<JSFunction> fun =
-      SimpleCreateFunction(isolate, fun_name, call, 0, adapt);
-  InstallGetter(base, name, fun);
-  return fun;
+  Handle<JSFunction> getter =
+      SimpleCreateFunction(isolate, getter_name, call, 0, adapt);
+  getter->shared()->set_native(true);
+
+  Handle<Object> setter = isolate->factory()->undefined_value();
+
+  JSObject::DefineAccessor(base, property_name, getter, setter, DONT_ENUM)
+      .Check();
+
+  return getter;
+}
+
+Handle<JSFunction> SimpleInstallGetter(Handle<JSObject> base,
+                                       Handle<String> name, Builtins::Name call,
+                                       bool adapt) {
+  return SimpleInstallGetter(base, name, name, call, adapt);
 }
 
 Handle<JSFunction> SimpleInstallGetter(Handle<JSObject> base,
@@ -1587,11 +1613,107 @@ void Genesis::InitializeGlobal(Handle<JSGlobalObject> global_object,
     shared->DontAdaptArguments();
     shared->set_length(2);
 
-    Handle<JSObject> proto =
-        factory->NewJSObject(isolate->object_function(), TENURED);
-    JSObject::AddProperty(proto, factory->constructor_string(), regexp_fun,
-                          DONT_ENUM);
-    Accessors::FunctionSetPrototype(regexp_fun, proto).Assert();
+    {
+      // RegExp.prototype setup.
+
+      Handle<JSObject> proto =
+          factory->NewJSObject(isolate->object_function(), TENURED);
+      JSObject::AddProperty(proto, factory->constructor_string(), regexp_fun,
+                            DONT_ENUM);
+      Accessors::FunctionSetPrototype(regexp_fun, proto).Assert();
+
+      SimpleInstallGetter(proto, factory->flags_string(),
+                          Builtins::kRegExpPrototypeFlagsGetter, false);
+      SimpleInstallGetter(proto, factory->global_string(),
+                          Builtins::kRegExpPrototypeGlobalGetter, false);
+      SimpleInstallGetter(proto, factory->ignoreCase_string(),
+                          Builtins::kRegExpPrototypeIgnoreCaseGetter, false);
+      SimpleInstallGetter(proto, factory->multiline_string(),
+                          Builtins::kRegExpPrototypeMultilineGetter, false);
+      SimpleInstallGetter(proto, factory->source_string(),
+                          Builtins::kRegExpPrototypeSourceGetter, false);
+      SimpleInstallGetter(proto, factory->sticky_string(),
+                          Builtins::kRegExpPrototypeStickyGetter, false);
+      SimpleInstallGetter(proto, factory->unicode_string(),
+                          Builtins::kRegExpPrototypeUnicodeGetter, false);
+    }
+
+    {
+      // RegExp getters and setters.
+
+      const PropertyAttributes no_enum_no_delete =
+          static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE);
+
+      SimpleInstallGetter(regexp_fun,
+                          factory->InternalizeUtf8String("[Symbol.species]"),
+                          factory->species_symbol(),
+                          Builtins::kRegExpPrototypeSpeciesGetter, false);
+
+      // Static properties set by a successful match.
+
+      SimpleInstallGetterSetter(regexp_fun, factory->input_string(),
+                                Builtins::kRegExpPrototypeInputGetter,
+                                Builtins::kRegExpPrototypeInputSetter,
+                                DONT_DELETE);
+      SimpleInstallGetterSetter(
+          regexp_fun, factory->InternalizeUtf8String("$_"),
+          Builtins::kRegExpPrototypeInputGetter,
+          Builtins::kRegExpPrototypeInputSetter, no_enum_no_delete);
+
+      SimpleInstallGetterSetter(regexp_fun,
+                                factory->InternalizeUtf8String("lastMatch"),
+                                Builtins::kRegExpPrototypeLastMatchGetter,
+                                Builtins::kEmptyFunction, no_enum_no_delete);
+      SimpleInstallGetterSetter(regexp_fun,
+                                factory->InternalizeUtf8String("$&"),
+                                Builtins::kRegExpPrototypeLastMatchGetter,
+                                Builtins::kEmptyFunction, no_enum_no_delete);
+
+      SimpleInstallGetterSetter(regexp_fun,
+                                factory->InternalizeUtf8String("lastParen"),
+                                Builtins::kRegExpPrototypeLastParenGetter,
+                                Builtins::kEmptyFunction, no_enum_no_delete);
+      SimpleInstallGetterSetter(regexp_fun,
+                                factory->InternalizeUtf8String("$+"),
+                                Builtins::kRegExpPrototypeLastParenGetter,
+                                Builtins::kEmptyFunction, no_enum_no_delete);
+
+      SimpleInstallGetterSetter(regexp_fun,
+                                factory->InternalizeUtf8String("leftContext"),
+                                Builtins::kRegExpPrototypeLeftContextGetter,
+                                Builtins::kEmptyFunction, no_enum_no_delete);
+      SimpleInstallGetterSetter(regexp_fun,
+                                factory->InternalizeUtf8String("$`"),
+                                Builtins::kRegExpPrototypeLeftContextGetter,
+                                Builtins::kEmptyFunction, no_enum_no_delete);
+
+      SimpleInstallGetterSetter(regexp_fun,
+                                factory->InternalizeUtf8String("rightContext"),
+                                Builtins::kRegExpPrototypeRightContextGetter,
+                                Builtins::kEmptyFunction, no_enum_no_delete);
+      SimpleInstallGetterSetter(regexp_fun,
+                                factory->InternalizeUtf8String("$'"),
+                                Builtins::kRegExpPrototypeRightContextGetter,
+                                Builtins::kEmptyFunction, no_enum_no_delete);
+
+#define INSTALL_CAPTURE_GETTER(i)                                         \
+  SimpleInstallGetterSetter(regexp_fun,                                   \
+                            factory->InternalizeUtf8String("$" #i),       \
+                            Builtins::kRegExpPrototypeCapture##i##Getter, \
+                            Builtins::kEmptyFunction, DONT_DELETE)
+      INSTALL_CAPTURE_GETTER(1);
+      INSTALL_CAPTURE_GETTER(2);
+      INSTALL_CAPTURE_GETTER(3);
+      INSTALL_CAPTURE_GETTER(4);
+      INSTALL_CAPTURE_GETTER(5);
+      INSTALL_CAPTURE_GETTER(6);
+      INSTALL_CAPTURE_GETTER(7);
+      INSTALL_CAPTURE_GETTER(8);
+      INSTALL_CAPTURE_GETTER(9);
+#undef INSTALL_CAPTURE_GETTER
+    }
+
+    // TODO(jgruber): shared->set_force_inline on getters.
 
     DCHECK(regexp_fun->has_initial_map());
     Handle<Map> initial_map(regexp_fun->initial_map());

src/builtins/builtins-regexp.cc

@@ -148,5 +148,249 @@ BUILTIN(RegExpConstructor) {
                            RegExpInitialize(isolate, regexp, pattern, flags));
 }
 
+#define APPEND_CHAR_FOR_FLAG(flag, c)                                        \
+  do {                                                                       \
+    Handle<Object> property;                                                 \
+    Handle<Name> name = isolate->factory()->flag##_string();                 \
+    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, property,                    \
+                                       JSReceiver::GetProperty(recv, name)); \
+    if (property->BooleanValue()) {                                          \
+      builder.AppendCharacter(c);                                            \
+    }                                                                        \
+  } while (false);
+
+// ES6 21.2.5.3.
+BUILTIN(RegExpPrototypeFlagsGetter) {
+  HandleScope scope(isolate);
+  CHECK_RECEIVER(JSReceiver, recv, "get RegExp.prototype.flags");
+
+  IncrementalStringBuilder builder(isolate);
+
+  APPEND_CHAR_FOR_FLAG(global, 'g');
+  APPEND_CHAR_FOR_FLAG(ignoreCase, 'i');
+  APPEND_CHAR_FOR_FLAG(multiline, 'm');
+  APPEND_CHAR_FOR_FLAG(unicode, 'u');
+  APPEND_CHAR_FOR_FLAG(sticky, 'y');
+
+  RETURN_RESULT_OR_FAILURE(isolate, builder.Finish());
+}
+
+#undef APPEND_CHAR_FOR_FLAG
+
+// ES6 21.2.5.10.
+BUILTIN(RegExpPrototypeSourceGetter) {
+  HandleScope scope(isolate);
+
+  Handle<Object> recv = args.receiver();
+  if (!recv->IsJSRegExp()) {
+    // TODO(littledan): Remove this RegExp compat workaround
+    Handle<JSFunction> regexp_fun = isolate->regexp_function();
+    if (*recv == regexp_fun->prototype()) {
+      isolate->CountUsage(v8::Isolate::kRegExpPrototypeSourceGetter);
+      return *isolate->factory()->NewStringFromAsciiChecked("(?:)");
+    }
+    THROW_NEW_ERROR_RETURN_FAILURE(
+        isolate, NewTypeError(MessageTemplate::kRegExpNonRegExp,
+                              isolate->factory()->NewStringFromAsciiChecked(
+                                  "RegExp.prototype.source")));
+  }
+
+  Handle<JSRegExp> regexp = Handle<JSRegExp>::cast(recv);
+  return regexp->source();
+}
+
+// ES6 21.2.4.2.
+BUILTIN(RegExpPrototypeSpeciesGetter) {
+  HandleScope scope(isolate);
+  return *args.receiver();
+}
+
+#define REGEXP_FLAG_GETTER(name, counter, getter)                              \
+  BUILTIN(RegExpPrototype##name##Getter) {                                     \
+    HandleScope scope(isolate);                                                \
+    Handle<Object> recv = args.receiver();                                     \
+    if (!recv->IsJSRegExp()) {                                                 \
+      /* TODO(littledan): Remove this RegExp compat workaround */              \
+      Handle<JSFunction> regexp_fun = isolate->regexp_function();              \
+      if (*recv == regexp_fun->prototype()) {                                  \
+        isolate->CountUsage(v8::Isolate::kRegExpPrototype##counter##Getter);   \
+        return isolate->heap()->undefined_value();                             \
+      }                                                                        \
+      THROW_NEW_ERROR_RETURN_FAILURE(                                          \
+          isolate, NewTypeError(MessageTemplate::kRegExpNonRegExp,             \
+                                isolate->factory()->NewStringFromAsciiChecked( \
+                                    getter)));                                 \
+    }                                                                          \
+    Handle<JSRegExp> regexp = Handle<JSRegExp>::cast(recv);                    \
+    const bool ret = (regexp->GetFlags() & JSRegExp::k##name) != 0;            \
+    return *isolate->factory()->ToBoolean(ret);                                \
+  }
+
+// ES6 21.2.5.4.
+REGEXP_FLAG_GETTER(Global, OldFlag, "RegExp.prototype.global")
+
+// ES6 21.2.5.5.
+REGEXP_FLAG_GETTER(IgnoreCase, OldFlag, "RegExp.prototype.ignoreCase")
+
+// ES6 21.2.5.7.
+REGEXP_FLAG_GETTER(Multiline, OldFlag, "RegExp.prototype.multiline")
+
+// ES6 21.2.5.12.
+REGEXP_FLAG_GETTER(Sticky, Sticky, "RegExp.prototype.sticky")
+
+// ES6 21.2.5.15.
+REGEXP_FLAG_GETTER(Unicode, Unicode, "RegExp.prototype.unicode")
+
+#undef REGEXP_FLAG_GETTER
+
+namespace {
+
+// Constants for accessing RegExpLastMatchInfo.
+// TODO(jgruber): Currently, RegExpLastMatchInfo is still a JSObject maintained
+// and accessed from JS. This is a crutch until all RegExp logic is ported, then
+// we can take care of RegExpLastMatchInfo.
+const int kNumberOfCapturesIndex = 0;
+const int kLastSubjectIndex = 1;
+const int kLastInputIndex = 2;
+const int kFirstCaptureIndex = 3;
+
+Handle<Object> GetLastMatchField(Isolate* isolate, int index) {
+  Handle<JSFunction> global_regexp = isolate->regexp_function();
+  Handle<Object> last_match_info_obj = JSReceiver::GetDataProperty(
+      global_regexp, isolate->factory()->regexp_last_match_info_symbol());
+
+  Handle<JSReceiver> last_match_info =
+      Handle<JSReceiver>::cast(last_match_info_obj);
+  return JSReceiver::GetElement(isolate, last_match_info, index)
+      .ToHandleChecked();
+}
+
+void SetLastMatchField(Isolate* isolate, int index, Handle<Object> value) {
+  Handle<JSFunction> global_regexp = isolate->regexp_function();
+  Handle<Object> last_match_info_obj = JSReceiver::GetDataProperty(
+      global_regexp, isolate->factory()->regexp_last_match_info_symbol());
+
+  Handle<JSReceiver> last_match_info =
+      Handle<JSReceiver>::cast(last_match_info_obj);
+  JSReceiver::SetElement(isolate, last_match_info, index, value, SLOPPY)
+      .ToHandleChecked();
+}
+
+int GetLastMatchNumberOfCaptures(Isolate* isolate) {
+  Handle<Object> obj = GetLastMatchField(isolate, kNumberOfCapturesIndex);
+  return Handle<Smi>::cast(obj)->value();
+}
+
+Handle<String> GetLastMatchSubject(Isolate* isolate) {
+  return Handle<String>::cast(GetLastMatchField(isolate, kLastSubjectIndex));
+}
+
+Handle<Object> GetLastMatchInput(Isolate* isolate) {
+  return GetLastMatchField(isolate, kLastInputIndex);
+}
+
+int GetLastMatchCapture(Isolate* isolate, int i) {
+  Handle<Object> obj = GetLastMatchField(isolate, kFirstCaptureIndex + i);
+  return Handle<Smi>::cast(obj)->value();
+}
+
+Object* GenericCaptureGetter(Isolate* isolate, int capture) {
+  HandleScope scope(isolate);
+  const int index = capture * 2;
+  if (index >= GetLastMatchNumberOfCaptures(isolate)) {
+    return isolate->heap()->empty_string();
+  }
+
+  const int match_start = GetLastMatchCapture(isolate, index);
+  const int match_end = GetLastMatchCapture(isolate, index + 1);
+  if (match_start == -1 || match_end == -1) {
+    return isolate->heap()->empty_string();
+  }
+
+  Handle<String> last_subject = GetLastMatchSubject(isolate);
+  return *isolate->factory()->NewSubString(last_subject, match_start,
+                                           match_end);
+}
+
+}  // namespace
+
+// The properties $1..$9 are the first nine capturing substrings of the last
+// successful match, or ''.  The function RegExpMakeCaptureGetter will be
+// called with indices from 1 to 9.
+#define DEFINE_CAPTURE_GETTER(i)               \
+  BUILTIN(RegExpPrototypeCapture##i##Getter) { \
+    HandleScope scope(isolate);                \
+    return GenericCaptureGetter(isolate, i);   \
+  }
+DEFINE_CAPTURE_GETTER(1)
+DEFINE_CAPTURE_GETTER(2)
+DEFINE_CAPTURE_GETTER(3)
+DEFINE_CAPTURE_GETTER(4)
+DEFINE_CAPTURE_GETTER(5)
+DEFINE_CAPTURE_GETTER(6)
+DEFINE_CAPTURE_GETTER(7)
+DEFINE_CAPTURE_GETTER(8)
+DEFINE_CAPTURE_GETTER(9)
+#undef DEFINE_CAPTURE_GETTER
+
+// The properties `input` and `$_` are aliases for each other.  When this
+// value is set the value it is set to is coerced to a string.
+// Getter and setter for the input.
+
+BUILTIN(RegExpPrototypeInputGetter) {
+  HandleScope scope(isolate);
+  Handle<Object> obj = GetLastMatchInput(isolate);
+  return obj->IsUndefined(isolate) ? isolate->heap()->empty_string()
+                                   : String::cast(*obj);
+}
+
+BUILTIN(RegExpPrototypeInputSetter) {
+  HandleScope scope(isolate);
+  Handle<Object> value = args.atOrUndefined(isolate, 1);
+  Handle<String> str;
+  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, str,
+                                     Object::ToString(isolate, value));
+  SetLastMatchField(isolate, kLastInputIndex, str);
+  return isolate->heap()->undefined_value();
+}
+
+// Getters for the static properties lastMatch, lastParen, leftContext, and
+// rightContext of the RegExp constructor.  The properties are computed based
+// on the captures array of the last successful match and the subject string
+// of the last successful match.
+BUILTIN(RegExpPrototypeLastMatchGetter) {
+  HandleScope scope(isolate);
+  return GenericCaptureGetter(isolate, 0);
+}
+
+BUILTIN(RegExpPrototypeLastParenGetter) {
+  HandleScope scope(isolate);
+  const int length = GetLastMatchNumberOfCaptures(isolate);
+  if (length <= 2) return isolate->heap()->empty_string();  // No captures.
+
+  DCHECK_EQ(0, length % 2);
+  const int last_capture = (length / 2) - 1;
+
+  // We match the SpiderMonkey behavior: return the substring defined by the
+  // last pair (after the first pair) of elements of the capture array even if
+  // it is empty.
+  return GenericCaptureGetter(isolate, last_capture);
+}
+
+BUILTIN(RegExpPrototypeLeftContextGetter) {
+  HandleScope scope(isolate);
+  const int start_index = GetLastMatchCapture(isolate, 0);
+  Handle<String> last_subject = GetLastMatchSubject(isolate);
+  return *isolate->factory()->NewSubString(last_subject, 0, start_index);
+}
+
+BUILTIN(RegExpPrototypeRightContextGetter) {
+  HandleScope scope(isolate);
+  const int start_index = GetLastMatchCapture(isolate, 1);
+  Handle<String> last_subject = GetLastMatchSubject(isolate);
+  const int len = last_subject->length();
+  return *isolate->factory()->NewSubString(last_subject, start_index, len);
+}
+
 }  // namespace internal
 }  // namespace v8

src/builtins/builtins.h

@@ -493,6 +493,29 @@ namespace internal {
                                                                               \
   /* RegExp */                                                                \
   CPP(RegExpConstructor)                                                      \
+  CPP(RegExpPrototypeCapture1Getter)                                          \
+  CPP(RegExpPrototypeCapture2Getter)                                          \
+  CPP(RegExpPrototypeCapture3Getter)                                          \
+  CPP(RegExpPrototypeCapture4Getter)                                          \
+  CPP(RegExpPrototypeCapture5Getter)                                          \
+  CPP(RegExpPrototypeCapture6Getter)                                          \
+  CPP(RegExpPrototypeCapture7Getter)                                          \
+  CPP(RegExpPrototypeCapture8Getter)                                          \
+  CPP(RegExpPrototypeCapture9Getter)                                          \
+  CPP(RegExpPrototypeFlagsGetter)                                             \
+  CPP(RegExpPrototypeGlobalGetter)                                            \
+  CPP(RegExpPrototypeIgnoreCaseGetter)                                        \
+  CPP(RegExpPrototypeInputGetter)                                             \
+  CPP(RegExpPrototypeInputSetter)                                             \
+  CPP(RegExpPrototypeLastMatchGetter)                                         \
+  CPP(RegExpPrototypeLastParenGetter)                                         \
+  CPP(RegExpPrototypeLeftContextGetter)                                       \
+  CPP(RegExpPrototypeMultilineGetter)                                         \
+  CPP(RegExpPrototypeRightContextGetter)                                      \
+  CPP(RegExpPrototypeSourceGetter)                                            \
+  CPP(RegExpPrototypeSpeciesGetter)                                           \
+  CPP(RegExpPrototypeStickyGetter)                                            \
+  CPP(RegExpPrototypeUnicodeGetter)                                           \
                                                                               \
   /* SharedArrayBuffer */                                                     \
   CPP(SharedArrayBufferPrototypeGetByteLength)                                \

src/heap-symbols.h

@@ -75,6 +75,7 @@
   V(get_string, "get")                                             \
   V(global_string, "global")                                       \
   V(has_string, "has")                                             \
+  V(ignoreCase_string, "ignoreCase")                               \
   V(illegal_access_string, "illegal access")                       \
   V(illegal_argument_string, "illegal argument")                   \
   V(index_string, "index")                                         \
@@ -97,6 +98,7 @@
   V(message_string, "message")                                     \
   V(minus_infinity_string, "-Infinity")                            \
   V(minus_zero_string, "-0")                                       \
+  V(multiline_string, "multiline")                                 \
   V(name_string, "name")                                           \
   V(nan_string, "NaN")                                             \
   V(next_string, "next")                                           \
@@ -130,6 +132,7 @@
   V(source_url_string, "source_url")                               \
   V(stack_string, "stack")                                         \
   V(stackTraceLimit_string, "stackTraceLimit")                     \
+  V(sticky_string, "sticky")                                       \
   V(strict_compare_ic_string, "===")                               \
   V(string_string, "string")                                       \
   V(String_string, "String")                                       \
@@ -151,6 +154,7 @@
   V(Uint8x16_string, "Uint8x16")                                   \
   V(undefined_string, "undefined")                                 \
   V(undefined_to_string, "[object Undefined]")                     \
+  V(unicode_string, "unicode")                                     \
   V(URIError_string, "URIError")                                   \
   V(valueOf_string, "valueOf")                                     \
   V(values_string, "values")                                       \
@@ -195,6 +199,7 @@
   V(promise_reject_reactions_symbol)        \
   V(promise_result_symbol)                  \
   V(promise_state_symbol)                   \
+  V(regexp_last_match_info_symbol)          \
   V(sealed_symbol)                          \
   V(stack_trace_symbol)                     \
   V(strict_function_transition_symbol)      \

src/js/regexp.js

@@ -17,6 +17,7 @@ var InternalArray = utils.InternalArray;
 var InternalPackedArray = utils.InternalPackedArray;
 var MaxSimple;
 var MinSimple;
+var lastMatchInfoSymbol = utils.ImportNow("regexp_last_match_info_symbol");
 var matchSymbol = utils.ImportNow("match_symbol");
 var replaceSymbol = utils.ImportNow("replace_symbol");
 var searchSymbol = utils.ImportNow("search_symbol");
@@ -923,180 +924,8 @@ function RegExpSubclassSearch(string) {
 %FunctionRemovePrototype(RegExpSubclassSearch);
 
 
-// Getters for the static properties lastMatch, lastParen, leftContext, and
-// rightContext of the RegExp constructor.  The properties are computed based
-// on the captures array of the last successful match and the subject string
-// of the last successful match.
-function RegExpGetLastMatch() {
-  var regExpSubject = LAST_SUBJECT(RegExpLastMatchInfo);
-  return %_SubString(regExpSubject,
-                     RegExpLastMatchInfo[CAPTURE0],
-                     RegExpLastMatchInfo[CAPTURE1]);
-}
-
-
-function RegExpGetLastParen() {
-  var length = NUMBER_OF_CAPTURES(RegExpLastMatchInfo);
-  if (length <= 2) return '';  // There were no captures.
-  // We match the SpiderMonkey behavior: return the substring defined by the
-  // last pair (after the first pair) of elements of the capture array even if
-  // it is empty.
-  var regExpSubject = LAST_SUBJECT(RegExpLastMatchInfo);
-  var start = RegExpLastMatchInfo[CAPTURE(length - 2)];
-  var end = RegExpLastMatchInfo[CAPTURE(length - 1)];
-  if (start != -1 && end != -1) {
-    return %_SubString(regExpSubject, start, end);
-  }
-  return "";
-}
-
-
-function RegExpGetLeftContext() {
-  var start_index;
-  var subject;
-  start_index = RegExpLastMatchInfo[CAPTURE0];
-  subject = LAST_SUBJECT(RegExpLastMatchInfo);
-  return %_SubString(subject, 0, start_index);
-}
-
-
-function RegExpGetRightContext() {
-  var start_index;
-  var subject;
-  start_index = RegExpLastMatchInfo[CAPTURE1];
-  subject = LAST_SUBJECT(RegExpLastMatchInfo);
-  return %_SubString(subject, start_index, subject.length);
-}
-
-
-// The properties $1..$9 are the first nine capturing substrings of the last
-// successful match, or ''.  The function RegExpMakeCaptureGetter will be
-// called with indices from 1 to 9.
-function RegExpMakeCaptureGetter(n) {
-  return function foo() {
-    var index = n * 2;
-    if (index >= NUMBER_OF_CAPTURES(RegExpLastMatchInfo)) return '';
-    var matchStart = RegExpLastMatchInfo[CAPTURE(index)];
-    var matchEnd = RegExpLastMatchInfo[CAPTURE(index + 1)];
-    if (matchStart == -1 || matchEnd == -1) return '';
-    return %_SubString(LAST_SUBJECT(RegExpLastMatchInfo), matchStart, matchEnd);
-  };
-}
-
-
-// ES6 21.2.5.3.
-function RegExpGetFlags() {
-  if (!IS_RECEIVER(this)) {
-    throw %make_type_error(
-        kRegExpNonObject, "RegExp.prototype.flags", TO_STRING(this));
-  }
-  var result = '';
-  if (this.global) result += 'g';
-  if (this.ignoreCase) result += 'i';
-  if (this.multiline) result += 'm';
-  if (this.unicode) result += 'u';
-  if (this.sticky) result += 'y';
-  return result;
-}
-
-
-// ES6 21.2.5.4.
-function RegExpGetGlobal() {
-  if (!IS_REGEXP(this)) {
-    // TODO(littledan): Remove this RegExp compat workaround
-    if (this === GlobalRegExp.prototype) {
-      %IncrementUseCounter(kRegExpPrototypeOldFlagGetter);
-      return UNDEFINED;
-    }
-    throw %make_type_error(kRegExpNonRegExp, "RegExp.prototype.global");
-  }
-  return TO_BOOLEAN(REGEXP_GLOBAL(this));
-}
-%SetForceInlineFlag(RegExpGetGlobal);
-
-
-// ES6 21.2.5.5.
-function RegExpGetIgnoreCase() {
-  if (!IS_REGEXP(this)) {
-    // TODO(littledan): Remove this RegExp compat workaround
-    if (this === GlobalRegExp.prototype) {
-      %IncrementUseCounter(kRegExpPrototypeOldFlagGetter);
-      return UNDEFINED;
-    }
-    throw %make_type_error(kRegExpNonRegExp, "RegExp.prototype.ignoreCase");
-  }
-  return TO_BOOLEAN(REGEXP_IGNORE_CASE(this));
-}
-
-
-// ES6 21.2.5.7.
-function RegExpGetMultiline() {
-  if (!IS_REGEXP(this)) {
-    // TODO(littledan): Remove this RegExp compat workaround
-    if (this === GlobalRegExp.prototype) {
-      %IncrementUseCounter(kRegExpPrototypeOldFlagGetter);
-      return UNDEFINED;
-    }
-    throw %make_type_error(kRegExpNonRegExp, "RegExp.prototype.multiline");
-  }
-  return TO_BOOLEAN(REGEXP_MULTILINE(this));
-}
-
-
-// ES6 21.2.5.10.
-function RegExpGetSource() {
-  if (!IS_REGEXP(this)) {
-    // TODO(littledan): Remove this RegExp compat workaround
-    if (this === GlobalRegExp.prototype) {
-      %IncrementUseCounter(kRegExpPrototypeSourceGetter);
-      return "(?:)";
-    }
-    throw %make_type_error(kRegExpNonRegExp, "RegExp.prototype.source");
-  }
-  return REGEXP_SOURCE(this);
-}
-
-
-// ES6 21.2.5.12.
-function RegExpGetSticky() {
-  if (!IS_REGEXP(this)) {
-    // Compat fix: RegExp.prototype.sticky == undefined; UseCounter tracks it
-    // TODO(littledan): Remove this workaround or standardize it
-    if (this === GlobalRegExp.prototype) {
-      %IncrementUseCounter(kRegExpPrototypeStickyGetter);
-      return UNDEFINED;
-    }
-    throw %make_type_error(kRegExpNonRegExp, "RegExp.prototype.sticky");
-  }
-  return TO_BOOLEAN(REGEXP_STICKY(this));
-}
-%SetForceInlineFlag(RegExpGetSticky);
-
-
-// ES6 21.2.5.15.
-function RegExpGetUnicode() {
-  if (!IS_REGEXP(this)) {
-    // TODO(littledan): Remove this RegExp compat workaround
-    if (this === GlobalRegExp.prototype) {
-      %IncrementUseCounter(kRegExpPrototypeUnicodeGetter);
-      return UNDEFINED;
-    }
-    throw %make_type_error(kRegExpNonRegExp, "RegExp.prototype.unicode");
-  }
-  return TO_BOOLEAN(REGEXP_UNICODE(this));
-}
-%SetForceInlineFlag(RegExpGetUnicode);
-
-
-function RegExpSpecies() {
-  return this;
-}
-
-
 // -------------------------------------------------------------------
 
-utils.InstallGetter(GlobalRegExp, speciesSymbol, RegExpSpecies);
-
 utils.InstallFunctions(GlobalRegExp.prototype, DONT_ENUM, [
   "exec", RegExpSubclassExecJS,
   "test", RegExpSubclassTest,
@@ -1108,58 +937,8 @@ utils.InstallFunctions(GlobalRegExp.prototype, DONT_ENUM, [
   splitSymbol, RegExpSubclassSplit,
 ]);
 
-utils.InstallGetter(GlobalRegExp.prototype, 'flags', RegExpGetFlags);
-utils.InstallGetter(GlobalRegExp.prototype, 'global', RegExpGetGlobal);
-utils.InstallGetter(GlobalRegExp.prototype, 'ignoreCase', RegExpGetIgnoreCase);
-utils.InstallGetter(GlobalRegExp.prototype, 'multiline', RegExpGetMultiline);
-utils.InstallGetter(GlobalRegExp.prototype, 'source', RegExpGetSource);
-utils.InstallGetter(GlobalRegExp.prototype, 'sticky', RegExpGetSticky);
-utils.InstallGetter(GlobalRegExp.prototype, 'unicode', RegExpGetUnicode);
-
-// The properties `input` and `$_` are aliases for each other.  When this
-// value is set the value it is set to is coerced to a string.
-// Getter and setter for the input.
-var RegExpGetInput = function() {
-  var regExpInput = LAST_INPUT(RegExpLastMatchInfo);
-  return IS_UNDEFINED(regExpInput) ? "" : regExpInput;
-};
-var RegExpSetInput = function(string) {
-  LAST_INPUT(RegExpLastMatchInfo) = TO_STRING(string);
-};
-
-%OptimizeObjectForAddingMultipleProperties(GlobalRegExp, 22);
-utils.InstallGetterSetter(GlobalRegExp, 'input', RegExpGetInput, RegExpSetInput,
-                          DONT_DELETE);
-utils.InstallGetterSetter(GlobalRegExp, '$_', RegExpGetInput, RegExpSetInput,
-                          DONT_ENUM | DONT_DELETE);
-
-
-var NoOpSetter = function(ignored) {};
-
-
-// Static properties set by a successful match.
-utils.InstallGetterSetter(GlobalRegExp, 'lastMatch', RegExpGetLastMatch,
-                          NoOpSetter, DONT_DELETE);
-utils.InstallGetterSetter(GlobalRegExp, '$&', RegExpGetLastMatch, NoOpSetter,
-                          DONT_ENUM | DONT_DELETE);
-utils.InstallGetterSetter(GlobalRegExp, 'lastParen', RegExpGetLastParen,
-                          NoOpSetter, DONT_DELETE);
-utils.InstallGetterSetter(GlobalRegExp, '$+', RegExpGetLastParen, NoOpSetter,
-                          DONT_ENUM | DONT_DELETE);
-utils.InstallGetterSetter(GlobalRegExp, 'leftContext', RegExpGetLeftContext,
-                          NoOpSetter, DONT_DELETE);
-utils.InstallGetterSetter(GlobalRegExp, '$`', RegExpGetLeftContext, NoOpSetter,
-                          DONT_ENUM | DONT_DELETE);
-utils.InstallGetterSetter(GlobalRegExp, 'rightContext', RegExpGetRightContext,
-                          NoOpSetter, DONT_DELETE);
-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);
+// Temporary until all RegExpLastMatchInfo accesses are ported to C++.
+SET_PRIVATE(GlobalRegExp, lastMatchInfoSymbol, RegExpLastMatchInfo);
 
 // -------------------------------------------------------------------
 // Internal

src/messages.h

@@ -418,7 +418,6 @@ class ErrorUtils : public AllStatic {
   T(ReduceNoInitial, "Reduce of empty array with no initial value")            \
   T(RegExpFlags,                                                               \
     "Cannot supply flags when constructing one RegExp from another")           \
-  T(RegExpNonObject, "% getter called on non-object %")                        \
   T(RegExpNonRegExp, "% getter called on non-RegExp object")                   \
   T(ReinitializeIntl, "Trying to re-initialize % object.")                     \
   T(ResolvedOptionsCalledOnNonObject,                                          \

test/cctest/interpreter/bytecode_expectations/ForOf.golden

@@ -87,7 +87,7 @@ bytecodes: [
                 B(TestEqualStrict), R(12), U8(20),
                 B(JumpIfFalse), U8(4),
                 B(Jump), U8(18),
-                B(Wide), B(LdaSmi), U16(129),
+                B(Wide), B(LdaSmi), U16(128),
                 B(Star), R(12),
                 B(LdaConstant), U8(8),
                 B(Star), R(13),
@@ -224,7 +224,7 @@ bytecodes: [
                 B(TestEqualStrict), R(13), U8(20),
                 B(JumpIfFalse), U8(4),
                 B(Jump), U8(18),
-                B(Wide), B(LdaSmi), U16(129),
+                B(Wide), B(LdaSmi), U16(128),
                 B(Star), R(13),
                 B(LdaConstant), U8(8),
                 B(Star), R(14),
@@ -375,7 +375,7 @@ bytecodes: [
                 B(TestEqualStrict), R(12), U8(22),
                 B(JumpIfFalse), U8(4),
                 B(Jump), U8(18),
-                B(Wide), B(LdaSmi), U16(129),
+                B(Wide), B(LdaSmi), U16(128),
                 B(Star), R(12),
                 B(LdaConstant), U8(8),
                 B(Star), R(13),
@@ -515,7 +515,7 @@ bytecodes: [
                 B(TestEqualStrict), R(11), U8(24),
                 B(JumpIfFalse), U8(4),
                 B(Jump), U8(18),
-                B(Wide), B(LdaSmi), U16(129),
+                B(Wide), B(LdaSmi), U16(128),
                 B(Star), R(11),
                 B(LdaConstant), U8(10),
                 B(Star), R(12),

test/cctest/interpreter/bytecode_expectations/Generators.golden

@@ -476,7 +476,7 @@ bytecodes: [
                 B(TestEqualStrict), R(11), U8(20),
                 B(JumpIfFalse), U8(4),
                 B(Jump), U8(18),
-                B(Wide), B(LdaSmi), U16(129),
+                B(Wide), B(LdaSmi), U16(128),
                 B(Star), R(11),
                 B(LdaConstant), U8(14),
                 B(Star), R(12),

test/mjsunit/messages.js

@@ -123,11 +123,6 @@ test(function() {
 }, "First argument to String.prototype.startsWith " +
    "must not be a regular expression", TypeError);
 
-// kFlagsGetterNonObject
-test(function() {
-  Object.getOwnPropertyDescriptor(RegExp.prototype, "flags").get.call(1);
-}, "RegExp.prototype.flags getter called on non-object 1", TypeError);
-
 // kFunctionBind
 test(function() {
   Function.prototype.bind.call(1);