[builtins] Move StringIncludes to a builtin.

src/builtins/builtins-regexp.cc

 // Copyright 2016 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/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 
 #include "src/code-factory.h"
 #include "src/regexp/jsregexp.h"
 
 namespace v8 {
 namespace internal {
 
 // -----------------------------------------------------------------------------
 // ES6 section 21.2 RegExp Objects
 
 namespace {
 
-// ES#sec-isregexp IsRegExp ( argument )
-Maybe<bool> IsRegExp(Isolate* isolate, Handle<Object> object) {
-  if (!object->IsJSReceiver()) return Just(false);
-
-  Handle<JSReceiver> receiver = Handle<JSReceiver>::cast(object);
-
-  if (isolate->regexp_function()->initial_map() == receiver->map()) {
-    // Fast-path for unmodified JSRegExp instances.
-    return Just(true);
-  }
-
-  Handle<Object> match;
-  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
-      isolate, match,
-      JSObject::GetProperty(receiver, isolate->factory()->match_symbol()),
-      Nothing<bool>());
-
-  if (!match->IsUndefined(isolate)) return Just(match->BooleanValue());
-  return Just(object->IsJSRegExp());
-}
-
 Handle<String> PatternFlags(Isolate* isolate, Handle<JSRegExp> regexp) {
   static const int kMaxFlagsLength = 5 + 1;  // 5 flags and '\0';
   char flags_string[kMaxFlagsLength];
   int i = 0;
 
   const JSRegExp::Flags flags = regexp->GetFlags();
 
   if ((flags & JSRegExp::kGlobal) != 0) flags_string[i++] = 'g';
   if ((flags & JSRegExp::kIgnoreCase) != 0) flags_string[i++] = 'i';
   if ((flags & JSRegExp::kMultiline) != 0) flags_string[i++] = 'm';
@@ skipping 42 matching lines @@
   HandleScope scope(isolate);
 
   Handle<HeapObject> new_target = args.new_target();
   Handle<Object> pattern = args.atOrUndefined(isolate, 1);
   Handle<Object> flags = args.atOrUndefined(isolate, 2);
 
   Handle<JSFunction> target = isolate->regexp_function();
 
   bool pattern_is_regexp;
   {
-    Maybe<bool> maybe_pattern_is_regexp = IsRegExp(isolate, pattern);
+    Maybe<bool> maybe_pattern_is_regexp = Object::IsRegExp(isolate, pattern);
     if (maybe_pattern_is_regexp.IsNothing()) {
       DCHECK(isolate->has_pending_exception());
       return isolate->heap()->exception();
     }
     pattern_is_regexp = maybe_pattern_is_regexp.FromJust();
   }
 
   if (new_target->IsUndefined(isolate)) {
     new_target = target;
 
@@ skipping 790 matching lines @@
 BUILTIN(RegExpRightContextGetter) {
   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