[base] Introduce VectorOf helper

We often need to create a {Vector} view of data owned by a container
like {std::vector}. The canonical way to do this is this:
Vector<T>{vec.data(), vec.size()}

This pattern is repeating information which can be deduced
automatically, like the type T.

This CL introduces a {VectorOf} helper which can construct a {Vector}
for any container providing a {data()} and {size()} accessor, and uses
it to replace the pattern above.

R=ishell@chromium.org

Bug: v8:8238
Change-Id: Ib3a11662acc82cb83f2b4afd07ba88e579d71dba
Reviewed-on: https://chromium-review.googlesource.com/c/1337584Reviewed-by: Igor Sheludko <ishell@chromium.org>
Commit-Queue: Clemens Hammacher <clemensh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#57538}

src/asmjs/asm-scanner.cc

@@ -308,8 +308,7 @@ void AsmJsScanner::ConsumeNumber(uc32 ch) {
   }
   // Decode numbers.
   double_value_ = StringToDouble(
-      Vector<const uint8_t>(reinterpret_cast<const uint8_t*>(number.data()),
-                            static_cast<int>(number.size())),
+      Vector<const uint8_t>::cast(VectorOf(number)),
       ALLOW_HEX | ALLOW_OCTAL | ALLOW_BINARY | ALLOW_IMPLICIT_OCTAL);
   if (std::isnan(double_value_)) {
     // Check if string to number conversion didn't consume all the characters.

src/json-parser.cc

@@ -34,8 +34,7 @@ class VectorSegment {
   ~VectorSegment() { container_.resize(begin_); }
 
   Vector<const value_type> GetVector() const {
-    return Vector<const value_type>(container_.data() + begin_,
-                                    container_.size() - begin_);
+    return VectorOf(container_) + begin_;
   }
 
   template <typename T>

src/uri.cc

@@ -307,8 +307,7 @@ MaybeHandle<String> Uri::Encode(Isolate* isolate, Handle<String> uri,
     }
   }
 
-  return isolate->factory()->NewStringFromOneByte(
-      Vector<const uint8_t>(buffer.data(), static_cast<int>(buffer.size())));
+  return isolate->factory()->NewStringFromOneByte(VectorOf(buffer));
 }
 
 namespace {  // Anonymous namespace for Escape and Unescape

src/vector.h

@@ -288,6 +288,15 @@ inline constexpr Vector<T> ArrayVector(T (&arr)[N]) {
   return Vector<T>(arr);
 }
 
+// Construct a Vector from anything providing a {data()} and {size()} accessor.
+template <typename Container,
+          typename T = typename std::remove_reference<
+              decltype(*(std::declval<Container>()).data())>::type,
+          typename = decltype((std::declval<Container>()).size())>
+inline constexpr Vector<T> VectorOf(Container&& c) {
+  return Vector<T>(c.data(), c.size());
+}
+
 }  // namespace internal
 }  // namespace v8
 

src/wasm/function-body-decoder-impl.h

@@ -127,11 +127,6 @@ struct WasmException;
   V(I64AtomicStore16U, Uint16)  \
   V(I64AtomicStore32U, Uint32)
 
-template <typename T, typename Allocator>
-Vector<T> vec2vec(std::vector<T, Allocator>& vec) {
-  return Vector<T>(vec.data(), vec.size());
-}
-
 // Helpers for decoding different kinds of immediates which follow bytecodes.
 template <Decoder::ValidateFlag validate>
 struct LocalIndexImmediate {
@@ -1491,7 +1486,7 @@ class WasmFullDecoder : public WasmDecoder<validate> {
             len = 1 + imm.length;
             if (!this->Validate(this->pc_, imm)) break;
             PopArgs(imm.exception->ToFunctionSig());
-            CALL_INTERFACE_IF_REACHABLE(Throw, imm, vec2vec(args_));
+            CALL_INTERFACE_IF_REACHABLE(Throw, imm, VectorOf(args_));
             EndControl();
             break;
           }
@@ -2278,7 +2273,7 @@ class WasmFullDecoder : public WasmDecoder<validate> {
         PopArgs(sig);
         auto* results =
             sig->return_count() == 0 ? nullptr : Push(GetReturnType(sig));
-        CALL_INTERFACE_IF_REACHABLE(SimdOp, opcode, vec2vec(args_), results);
+        CALL_INTERFACE_IF_REACHABLE(SimdOp, opcode, VectorOf(args_), results);
       }
     }
     return len;
@@ -2316,7 +2311,7 @@ class WasmFullDecoder : public WasmDecoder<validate> {
       len += imm.length;
       PopArgs(sig);
       auto result = ret_type == kWasmStmt ? nullptr : Push(GetReturnType(sig));
-      CALL_INTERFACE_IF_REACHABLE(AtomicOp, opcode, vec2vec(args_), imm,
+      CALL_INTERFACE_IF_REACHABLE(AtomicOp, opcode, VectorOf(args_), imm,
                                   result);
     } else {
       this->error("invalid atomic opcode");
@@ -2335,7 +2330,7 @@ class WasmFullDecoder : public WasmDecoder<validate> {
 
     // Simulate that an implicit return morally comes after the current block.
     if (implicit && c->end_merge.reached) c->reachability = kReachable;
-    CALL_INTERFACE_IF_REACHABLE(DoReturn, vec2vec(args_), implicit);
+    CALL_INTERFACE_IF_REACHABLE(DoReturn, VectorOf(args_), implicit);
 
     EndControl();
   }

src/wasm/graph-builder-interface.cc

@@ -414,7 +414,7 @@ class WasmGraphBuildingInterface {
     for (int i = 0; i < count; ++i) {
       args[i] = value_args[i].node;
     }
-    BUILD(Throw, imm.index, imm.exception, vec2vec(args));
+    BUILD(Throw, imm.index, imm.exception, VectorOf(args));
     builder_->TerminateThrow(ssa_env_->effect, ssa_env_->control);
   }
 

src/wasm/module-compiler.cc

@@ -1308,9 +1308,7 @@ MaybeHandle<WasmInstanceObject> InstanceBuilder::Build() {
          func_index < num_wasm_functions; ++func_index) {
       func_indexes.push_back(func_index);
     }
-    WasmDebugInfo::RedirectToInterpreter(
-        debug_info, Vector<int>(func_indexes.data(),
-                                static_cast<int>(func_indexes.size())));
+    WasmDebugInfo::RedirectToInterpreter(debug_info, VectorOf(func_indexes));
   }
 
   //--------------------------------------------------------------------------

src/wasm/streaming-decoder.cc

@@ -66,8 +66,7 @@ void StreamingDecoder::Finish() {
   if (!ok()) return;
 
   if (deserializing()) {
-    Vector<const uint8_t> wire_bytes(wire_bytes_for_deserializing_.data(),
-                                     wire_bytes_for_deserializing_.size());
+    Vector<const uint8_t> wire_bytes = VectorOf(wire_bytes_for_deserializing_);
     // Try to deserialize the module from wire bytes and module bytes.
     if (processor_->Deserialize(compiled_module_bytes_, wire_bytes)) return;
 

src/wasm/wasm-result.cc

@@ -126,9 +126,9 @@ Handle<Object> ErrorThrower::Reify() {
       constructor = isolate_->wasm_runtime_error_function();
       break;
   }
-  Vector<const char> msg_vec(error_msg_.data(), error_msg_.size());
-  Handle<String> message =
-      isolate_->factory()->NewStringFromUtf8(msg_vec).ToHandleChecked();
+  Handle<String> message = isolate_->factory()
+                               ->NewStringFromUtf8(VectorOf(error_msg_))
+                               .ToHandleChecked();
   Reset();
   return isolate_->factory()->NewError(constructor, message);
 }

src/wasm/wasm-serialization.cc

@@ -383,14 +383,14 @@ WasmSerializer::WasmSerializer(Isolate* isolate, NativeModule* native_module)
       code_table_(native_module->SnapshotCodeTable()) {}
 
 size_t WasmSerializer::GetSerializedNativeModuleSize() const {
-  Vector<WasmCode* const> code_table(code_table_.data(), code_table_.size());
-  NativeModuleSerializer serializer(isolate_, native_module_, code_table);
+  NativeModuleSerializer serializer(isolate_, native_module_,
+                                    VectorOf(code_table_));
   return kVersionSize + serializer.Measure();
 }
 
 bool WasmSerializer::SerializeNativeModule(Vector<byte> buffer) const {
-  Vector<WasmCode* const> code_table(code_table_.data(), code_table_.size());
-  NativeModuleSerializer serializer(isolate_, native_module_, code_table);
+  NativeModuleSerializer serializer(isolate_, native_module_,
+                                    VectorOf(code_table_));
   size_t measured_size = kVersionSize + serializer.Measure();
   if (buffer.size() < measured_size) return false;
 

test/unittests/unicode-unittest.cc

@@ -29,8 +29,7 @@ template <size_t kBufferSize>
 void DecodeUtf16(unibrow::Utf8Decoder<kBufferSize>* decoder,
                  const std::vector<byte>& bytes,
                  std::vector<unibrow::uchar>* output) {
-  const char* bytes_begin = reinterpret_cast<const char*>(&(*bytes.begin()));
-  auto vector = Vector<const char>(bytes_begin, bytes.size());
+  auto vector = Vector<const char>::cast(VectorOf(bytes));
   decoder->Reset(vector);
 
   std::vector<uint16_t> utf16(decoder->Utf16Length());