[stubs] Remove StringIndexOfChar

src/builtins/builtins-string.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-regexp.h"
 #include "src/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/regexp/regexp-utils.h"
@@ skipping 1162 matching lines @@
                         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 tostring_callable = CodeFactory::ToString(isolate());
+  Callable indexof_callable = CodeFactory::StringIndexOf(isolate());
+
   Node* const subject_string = CallStub(tostring_callable, context, receiver);
   Node* const search_string = CallStub(tostring_callable, context, search);
 
   Node* const subject_length = LoadStringLength(subject_string);
   Node* const search_length = LoadStringLength(search_string);
 
   // Fast-path single-char {search}, long {receiver}, and simple string
   // {replace}.
   {
     Label next(this);
 
     GotoUnless(SmiEqual(search_length, SmiConstant(1)), &next);
     GotoUnless(SmiGreaterThan(subject_length, SmiConstant(0xFF)), &next);
     GotoIf(TaggedIsSmi(replace), &next);
     GotoUnless(IsString(replace), &next);
 
-    Node* const dollar_char = Int32Constant('$');
-    Node* const index_of_dollar =
-        StringIndexOfChar(context, replace, dollar_char, smi_zero);
-    GotoUnless(SmiIsNegative(index_of_dollar), &next);
+    Node* const dollar_string = HeapConstant(
+        isolate()->factory()->LookupSingleCharacterStringFromCode('$'));
+    Node* const dollar_ix =
+        CallStub(indexof_callable, context, replace, dollar_string, smi_zero);
+    GotoUnless(SmiIsNegative(dollar_ix), &next);
 
     // Searching by traversing a cons string tree and replace with cons of
     // slices works only when the replaced string is a single character, being
     // replaced by a simple string and only pays off for long strings.
     // TODO(jgruber): Reevaluate if this is still beneficial.
     TailCallRuntime(Runtime::kStringReplaceOneCharWithString, context,
                     subject_string, search_string, replace);
 
     Bind(&next);
   }
 
-  // TODO(jgruber): Extend StringIndexOfChar to handle two-byte strings and
+  // TODO(jgruber): Extend StringIndexOf to handle two-byte strings and
   // longer substrings - we can handle up to 8 chars (one-byte) / 4 chars
   // (2-byte).
 
-  Callable indexof_stub = CodeFactory::StringIndexOf(isolate());
-  Node* const match_start_index =
-      CallStub(indexof_stub, context, subject_string, search_string, smi_zero);
+  Node* const match_start_index = CallStub(
+      indexof_callable, context, subject_string, search_string, smi_zero);
   CSA_ASSERT(this, TaggedIsSmi(match_start_index));
 
   // Early exit if no match found.
   {
     Label next(this), return_subject(this);
 
     GotoUnless(SmiIsNegative(match_start_index), &next);
 
     // The spec requires to perform ToString(replace) if the {replace} is not
     // callable even if we are going to exit here.
@@ skipping 640 matching lines @@
         CallRuntime(Runtime::kThrowIncompatibleMethodReceiver, context,
                     HeapConstant(factory()->NewStringFromAsciiChecked(
                         "String Iterator.prototype.next", TENURED)),
                     iterator);
     Return(result);  // Never reached.
   }
 }
 
 }  // namespace internal
 }  // namespace v8