[builtins] Begin removing CodeFactory accessors

src/builtins/builtins-string-gen.cc

 // Copyright 2017 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-string-gen.h"
 
 #include "src/builtins/builtins-regexp-gen.h"
 #include "src/builtins/builtins-utils-gen.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
@@ skipping 1126 matching lines @@
 
   RequireObjectCoercible(context, receiver, "String.prototype.replace");
 
   // Redirect to replacer method if {search[@@replace]} is not undefined.
 
   MaybeCallFunctionAtSymbol(
       context, search, isolate()->factory()->replace_symbol(),
       [=]() {
         Node* const subject_string = ToString_Inline(context, receiver);
 
-        Callable replace_callable = CodeFactory::RegExpReplace(isolate());
-        return CallStub(replace_callable, context, search, subject_string,
-                        replace);
+        return CallBuiltin(Builtins::kRegExpReplace, context, search,
+                           subject_string, replace);
       },
       [=](Node* fn) {
         Callable call_callable = CodeFactory::Call(isolate());
         return CallJS(call_callable, context, fn, search, receiver, replace);
       });
 
   // Convert {receiver} and {search} to strings.
 
   Callable indexof_callable = CodeFactory::StringIndexOf(isolate());
 
@@ skipping 138 matching lines @@
       args.GetOptionalArgumentValue(kStart, UndefinedConstant());
   Node* const end = args.GetOptionalArgumentValue(kEnd, UndefinedConstant());
   Node* const context = Parameter(BuiltinDescriptor::kContext);
 
   Node* const smi_zero = SmiConstant(0);
 
   // 1. Let O be ? RequireObjectCoercible(this value).
   RequireObjectCoercible(context, receiver, "String.prototype.slice");
 
   // 2. Let S be ? ToString(O).
-  Callable tostring_callable = CodeFactory::ToString(isolate());
-  Node* const subject_string = CallStub(tostring_callable, context, receiver);
+  Node* const subject_string =
+      CallBuiltin(Builtins::kToString, context, receiver);
 
   // 3. Let len be the number of elements in S.
   Node* const length = LoadStringLength(subject_string);
 
   // Conversions and bounds-checks for {start}.
   ConvertAndBoundsCheckStartArgument(context, &var_start, start, length);
 
   // 5. If end is undefined, let intEnd be len;
   var_end.Bind(length);
   GotoIf(WordEqual(end, UndefinedConstant()), &out);
@@ skipping 58 matching lines @@
 
   RequireObjectCoercible(context, receiver, "String.prototype.split");
 
   // Redirect to splitter method if {separator[@@split]} is not undefined.
 
   MaybeCallFunctionAtSymbol(
       context, separator, isolate()->factory()->split_symbol(),
       [=]() {
         Node* const subject_string = ToString_Inline(context, receiver);
 
-        Callable split_callable = CodeFactory::RegExpSplit(isolate());
-        return CallStub(split_callable, context, separator, subject_string,
-                        limit);
+        return CallBuiltin(Builtins::kRegExpSplit, context, separator,
+                           subject_string, limit);
       },
       [=](Node* fn) {
         Callable call_callable = CodeFactory::Call(isolate());
         return CallJS(call_callable, context, fn, separator, receiver, limit);
       });
 
   // String and integer conversions.
   // TODO(jgruber): The old implementation used Uint32Max instead of SmiMax -
   // but AFAIK there should not be a difference since arrays are capped at Smi
   // lengths.
@@ skipping 420 matching lines @@
     CallRuntime(Runtime::kThrowIncompatibleMethodReceiver, context,
                 HeapConstant(factory()->NewStringFromAsciiChecked(
                     "String Iterator.prototype.next", TENURED)),
                 iterator);
     Unreachable();
   }
 }
 
 }  // namespace internal
 }  // namespace v8