From 5a11048c340af835800db887fd6fc312d09dcee9 Mon Sep 17 00:00:00 2001
From: David Blaikie <dblaikie@gmail.com>
Date: Thu, 22 Aug 2024 12:40:54 -0700
Subject: [PATCH] Remove some explicit (Mutable)ArrayRef constructions (#4238)

Rely on implicit conversion in call sites and initialization.

Removing the explicit conversions is only code simplication.
Moving from `auto x = Y(z)` to `Y x = z;` helps ensure that only
implicit constructors/conversions are happening (whereas the prior
syntax allows explicit conversions) which can help with readability
since implicit conversions are generally "less
complex"/risky/attention-requiring.
---
 common/hashing_test.cpp                           | 15 +++++++--------
 common/raw_hashtable_metadata_group_benchmark.cpp |  2 +-
 toolchain/driver/driver.cpp                       |  3 +--
 3 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/common/hashing_test.cpp b/common/hashing_test.cpp
index 8bc65c0f71c9..98d18d52172f 100644
--- a/common/hashing_test.cpp
+++ b/common/hashing_test.cpp
@@ -286,12 +286,11 @@ TEST(HashingTest, BasicStrings) {
 
 TEST(HashingTest, ArrayLike) {
   int c_array[] = {1, 2, 3, 4};
-  llvm::ArrayRef arr = c_array;
-  EXPECT_THAT(HashValue(c_array), Eq(HashValue(arr)));
-  EXPECT_THAT(HashValue(std::array{1, 2, 3, 4}), Eq(HashValue(arr)));
-  EXPECT_THAT(HashValue(std::vector{1, 2, 3, 4}), Eq(HashValue(arr)));
+  EXPECT_THAT(HashValue(c_array), Eq(HashValue(c_array)));
+  EXPECT_THAT(HashValue(std::array{1, 2, 3, 4}), Eq(HashValue(c_array)));
+  EXPECT_THAT(HashValue(std::vector{1, 2, 3, 4}), Eq(HashValue(c_array)));
   EXPECT_THAT(HashValue(llvm::SmallVector<int>{1, 2, 3, 4}),
-              Eq(HashValue(arr)));
+              Eq(HashValue(c_array)));
 }
 
 TEST(HashingTest, HashAPInt) {
@@ -700,7 +699,7 @@ auto ExpectNoHashCollisions(llvm::ArrayRef<HashedString> hashes) -> void {
 
 TEST(HashingTest, Collisions1ByteSized) {
   auto hashes_storage = AllByteStringsHashedAndSorted<1>();
-  auto hashes = llvm::ArrayRef(hashes_storage);
+  llvm::ArrayRef hashes = hashes_storage;
   ExpectNoHashCollisions(hashes);
 
   auto low_32bit_collisions = FindBitRangeCollisions<0, 32>(hashes);
@@ -725,7 +724,7 @@ TEST(HashingTest, Collisions1ByteSized) {
 
 TEST(HashingTest, Collisions2ByteSized) {
   auto hashes_storage = AllByteStringsHashedAndSorted<2>();
-  auto hashes = llvm::ArrayRef(hashes_storage);
+  llvm::ArrayRef hashes = hashes_storage;
   ExpectNoHashCollisions(hashes);
 
   auto low_32bit_collisions = FindBitRangeCollisions<0, 32>(hashes);
@@ -855,7 +854,7 @@ TYPED_TEST_SUITE(SparseHashTest, SparseHashTestParams);
 
 TYPED_TEST(SparseHashTest, Collisions) {
   auto hashes_storage = this->GetHashedByteStrings();
-  auto hashes = llvm::ArrayRef(hashes_storage);
+  llvm::ArrayRef hashes = hashes_storage;
   ExpectNoHashCollisions(hashes);
 
   int min_7bit_collisions = llvm::NextPowerOf2(hashes.size() - 1) / (1 << 7);
diff --git a/common/raw_hashtable_metadata_group_benchmark.cpp b/common/raw_hashtable_metadata_group_benchmark.cpp
index 62f85f53cfde..b1fa2326dd5f 100644
--- a/common/raw_hashtable_metadata_group_benchmark.cpp
+++ b/common/raw_hashtable_metadata_group_benchmark.cpp
@@ -122,7 +122,7 @@ static auto BuildBenchMetadata() -> llvm::ArrayRef<BenchMetadata> {
 
     for (ssize_t g_index : llvm::seq<ssize_t>(0, BenchSize)) {
       // Start by filling the group with random bytes.
-      auto group_bytes = llvm::MutableArrayRef(
+      llvm::MutableArrayRef group_bytes(
           &metadata_storage[bm_index][g_index * GroupSize], GroupSize);
       for (uint8_t& b : group_bytes) {
         b = absl::Uniform<uint8_t>(gen) | MetadataGroup::PresentMask;
diff --git a/toolchain/driver/driver.cpp b/toolchain/driver/driver.cpp
index 6b6e8714753f..b4982aeaa25e 100644
--- a/toolchain/driver/driver.cpp
+++ b/toolchain/driver/driver.cpp
@@ -945,8 +945,7 @@ auto Driver::Compile(const CompileOptions& options,
     }
   }
   CARBON_VLOG() << "*** Check::CheckParseTrees ***\n";
-  Check::CheckParseTrees(llvm::MutableArrayRef(check_units),
-                         options.prelude_import, vlog_stream_);
+  Check::CheckParseTrees(check_units, options.prelude_import, vlog_stream_);
   CARBON_VLOG() << "*** Check::CheckParseTrees done ***\n";
   for (auto& unit : units) {
     if (unit->has_source()) {