[builtins] Move StringIndexOf to a C++ builtin.

src/objects.cc

 // Copyright 2015 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/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <memory>
 #include <sstream>
@@ skipping 11577 matching lines @@
     }
   }
   if (r < 0) {
     result = ComparisonResult::kLessThan;
   } else if (r > 0) {
     result = ComparisonResult::kGreaterThan;
   }
   return result;
 }
 
-int String::IndexOf(Isolate* isolate, Handle<String> sub, Handle<String> pat,
-                    int start_index) {
-  DCHECK(0 <= start_index);
-  DCHECK(start_index <= sub->length());
+Object* String::IndexOf(Isolate* isolate, Handle<Object> receiver,
+                        Handle<Object> pattern, Handle<Object> position) {
+  if (receiver->IsNull(isolate) || receiver->IsUndefined(isolate)) {
+    THROW_NEW_ERROR_RETURN_FAILURE(
+        isolate, NewTypeError(MessageTemplate::kCalledOnNullOrUndefined,
+                              isolate->factory()->NewStringFromAsciiChecked(
+                                  "String.prototype.lastIndexOf")));

[Franzi, 2016/09/20 17:03:27]

Should this be String.prototpye.indexOf?

[petermarshall, 2016/09/22 13:54:24]

It definitely should

+  }
+  Handle<String> sub;
+  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, sub,
+                                     Object::ToString(isolate, receiver));
+  Handle<String> pat;
+  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, pat,
+                                     Object::ToString(isolate, pattern));
+  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, position,
+                                     Object::ToInteger(isolate, position));
 
-  int pattern_length = pat->length();
-  if (pattern_length == 0) return start_index;
+  double position_number = std::max(position->Number(), 0.0);
+  position_number =
+      std::min(position_number, static_cast<double>(sub->length()));
+  uint32_t start_index = static_cast<uint32_t>(position_number);
 
-  int subject_length = sub->length();
-  if (start_index + pattern_length > subject_length) return -1;
+  uint32_t pattern_length = pat->length();
+  if (pattern_length == 0) return Smi::FromInt(start_index);
+
+  uint32_t subject_length = sub->length();
+  if (start_index + pattern_length > subject_length) return Smi::FromInt(-1);
 
   sub = String::Flatten(sub);
   pat = String::Flatten(pat);
 
+  int first_index = -1;

[Franzi, 2016/09/20 17:03:27]

first_index is overwritten in any case, right? Can we inline it and call 
return Smi::FromInt(SearchString(...)) 
directly?

[petermarshall, 2016/09/22 13:54:24]

Yep that's a bit nicer

   DisallowHeapAllocation no_gc;  // ensure vectors stay valid
   // Extract flattened substrings of cons strings before getting encoding.
   String::FlatContent seq_sub = sub->GetFlatContent();
   String::FlatContent seq_pat = pat->GetFlatContent();
 
   // dispatch on type of strings
   if (seq_pat.IsOneByte()) {
     Vector<const uint8_t> pat_vector = seq_pat.ToOneByteVector();
     if (seq_sub.IsOneByte()) {
-      return SearchString(isolate, seq_sub.ToOneByteVector(), pat_vector,
-                          start_index);
+      first_index = SearchString(isolate, seq_sub.ToOneByteVector(), pat_vector,
+                                 start_index);
+    } else {
+      first_index = SearchString(isolate, seq_sub.ToUC16Vector(), pat_vector,
+                                 start_index);
     }
-    return SearchString(isolate, seq_sub.ToUC16Vector(), pat_vector,
-                        start_index);
+  } else {
+    Vector<const uc16> pat_vector = seq_pat.ToUC16Vector();
+    if (seq_sub.IsOneByte()) {

[Franzi, 2016/09/20 17:03:27]

Would it make sense to extract this if-else statement into a templated function
since it's the same as above? Or would that decrease readability?

[petermarshall, 2016/09/22 13:54:24]

Could be a good idea, I'm not completely sure of a nice way to do it, let's chat
offline about it.

+      first_index = SearchString(isolate, seq_sub.ToOneByteVector(), pat_vector,
+                                 start_index);
+    } else {
+      first_index = SearchString(isolate, seq_sub.ToUC16Vector(), pat_vector,
+                                 start_index);
+    }
   }
-  Vector<const uc16> pat_vector = seq_pat.ToUC16Vector();
-  if (seq_sub.IsOneByte()) {
-    return SearchString(isolate, seq_sub.ToOneByteVector(), pat_vector,
-                        start_index);
-  }
-  return SearchString(isolate, seq_sub.ToUC16Vector(), pat_vector, start_index);
+  return Smi::FromInt(first_index);
 }
 
 namespace {  // for String.Prototype.lastIndexOf
 
 template <typename schar, typename pchar>
 int StringMatchBackwards(Vector<const schar> subject,
                          Vector<const pchar> pattern, int idx) {
   int pattern_length = pattern.length();
   DCHECK(pattern_length >= 1);
   DCHECK(idx + pattern_length <= subject.length());
@@ skipping 7956 matching lines @@
 
 Handle<Object> Module::LoadExport(Handle<Module> module, Handle<String> name) {
   Isolate* isolate = module->GetIsolate();
   Handle<ObjectHashTable> exports(module->exports(), isolate);
   Handle<Cell> cell(Cell::cast(exports->Lookup(name)));
   return handle(cell->value(), isolate);
 }
 
 }  // namespace internal
 }  // namespace v8