Move from llvm::makeArrayRef to ArrayRef deduction guides - llvm/ part

Use deduction guides instead of helper functions.

The only non-automatic changes have been:

1. ArrayRef(some_uint8_pointer, 0) needs to be changed into ArrayRef(some_uint8_pointer, (size_t)0) to avoid an ambiguous call with ArrayRef((uint8_t*), (uint8_t*))
2. CVSymbol sym(makeArrayRef(symStorage)); needed to be rewritten as CVSymbol sym{ArrayRef(symStorage)}; otherwise the compiler is confused and thinks we have a (bad) function prototype. There was a few similar situation across the codebase.
3. ADL doesn't seem to work the same for deduction-guides and functions, so at some point the llvm namespace must be explicitly stated.
4. The "reference mode" of makeArrayRef(ArrayRef<T> &) that acts as no-op is not supported (a constructor cannot achieve that).

Per reviewers' comment, some useless makeArrayRef have been removed in the process.

This is a follow-up to https://reviews.llvm.org/D140896 that introduced
the deduction guides.

Differential Revision: https://reviews.llvm.org/D140955

28 files changed, 137 insertions, 138 deletions

diff --git a/llvm/unittests/ADT/ArrayRefTest.cpp b/llvm/unittests/ADT/ArrayRefTest.cpp
index 9fcddc8..0aea5a9 100644
--- a/llvm/unittests/ADT/ArrayRefTest.cpp
+++ b/llvm/unittests/ADT/ArrayRefTest.cpp
@@ -44,9 +44,9 @@ namespace {
 TEST(ArrayRefTest, AllocatorCopy) {
   BumpPtrAllocator Alloc;
   static const uint16_t Words1[] = { 1, 4, 200, 37 };
-  ArrayRef<uint16_t> Array1 = makeArrayRef(Words1, 4);
+  ArrayRef<uint16_t> Array1 = ArrayRef(Words1, 4);
   static const uint16_t Words2[] = { 11, 4003, 67, 64000, 13 };
-  ArrayRef<uint16_t> Array2 = makeArrayRef(Words2, 5);
+  ArrayRef<uint16_t> Array2 = ArrayRef(Words2, 5);
   ArrayRef<uint16_t> Array1c = Array1.copy(Alloc);
   ArrayRef<uint16_t> Array2c = Array2.copy(Alloc);
   EXPECT_TRUE(Array1.equals(Array1c));
@@ -63,9 +63,9 @@ TEST(ArrayRefTest, AllocatorCopy) {
     void operator=(const NonAssignable &RHS) { assert(RHS.Ptr != nullptr); }
     bool operator==(const NonAssignable &RHS) const { return Ptr == RHS.Ptr; }
   } Array3Src[] = {"hello", "world"};
-  ArrayRef<NonAssignable> Array3Copy = makeArrayRef(Array3Src).copy(Alloc);
-  EXPECT_EQ(makeArrayRef(Array3Src), Array3Copy);
-  EXPECT_NE(makeArrayRef(Array3Src).data(), Array3Copy.data());
+  ArrayRef<NonAssignable> Array3Copy = ArrayRef(Array3Src).copy(Alloc);
+  EXPECT_EQ(ArrayRef(Array3Src), Array3Copy);
+  EXPECT_NE(ArrayRef(Array3Src).data(), Array3Copy.data());
 }
 
 // This test is pure UB given the ArrayRef<> implementation.
@@ -222,31 +222,32 @@ TEST(ArrayRefTest, EmptyInitializerList) {
   EXPECT_TRUE(A.empty());
 }
 
-TEST(ArrayRefTest, makeArrayRef) {
+TEST(ArrayRefTest, ArrayRef) {
   static const int A1[] = {1, 2, 3, 4, 5, 6, 7, 8};
 
-  // No copy expected for non-const ArrayRef (true no-op)
+  // A copy is expected for non-const ArrayRef (thin copy)
   ArrayRef<int> AR1(A1);
-  ArrayRef<int> &AR1Ref = makeArrayRef(AR1);
-  EXPECT_EQ(&AR1, &AR1Ref);
+  const ArrayRef<int> &AR1Ref = ArrayRef(AR1);
+  EXPECT_NE(&AR1, &AR1Ref);
+  EXPECT_TRUE(AR1.equals(AR1Ref));
 
   // A copy is expected for non-const ArrayRef (thin copy)
   const ArrayRef<int> AR2(A1);
-  const ArrayRef<int> &AR2Ref = makeArrayRef(AR2);
+  const ArrayRef<int> &AR2Ref = ArrayRef(AR2);
   EXPECT_NE(&AR2Ref, &AR2);
   EXPECT_TRUE(AR2.equals(AR2Ref));
 }
 
 TEST(ArrayRefTest, OwningArrayRef) {
   static const int A1[] = {0, 1};
-  OwningArrayRef<int> A(makeArrayRef(A1));
+  OwningArrayRef<int> A{ArrayRef(A1)};
   OwningArrayRef<int> B(std::move(A));
   EXPECT_EQ(A.data(), nullptr);
 }
 
-TEST(ArrayRefTest, makeArrayRefFromStdArray) {
+TEST(ArrayRefTest, ArrayRefFromStdArray) {
   std::array<int, 5> A1{{42, -5, 0, 1000000, -1000000}};
-  ArrayRef<int> A2 = makeArrayRef(A1);
+  ArrayRef<int> A2 = ArrayRef(A1);
 
   EXPECT_EQ(A1.size(), A2.size());
   for (std::size_t i = 0; i < A1.size(); ++i) {
diff --git a/llvm/unittests/ADT/EditDistanceTest.cpp b/llvm/unittests/ADT/EditDistanceTest.cpp
index 6e35f1b5..84c8532 100644
--- a/llvm/unittests/ADT/EditDistanceTest.cpp
+++ b/llvm/unittests/ADT/EditDistanceTest.cpp
@@ -29,8 +29,8 @@ static Result editDistanceAndMaps(StringRef A, StringRef B,
     return X;
   };
   unsigned EditDist = llvm::ComputeMappedEditDistance(
-      makeArrayRef(A.data(), A.size()), makeArrayRef(B.data(), B.size()),
-      TrackMaps, true, MaxEditDistance);
+      ArrayRef(A.data(), A.size()), ArrayRef(B.data(), B.size()), TrackMaps,
+      true, MaxEditDistance);
   return {NumMaps, EditDist};
 }
 
diff --git a/llvm/unittests/ADT/SmallVectorTest.cpp b/llvm/unittests/ADT/SmallVectorTest.cpp
index 62e6f433..fd3780a 100644
--- a/llvm/unittests/ADT/SmallVectorTest.cpp
+++ b/llvm/unittests/ADT/SmallVectorTest.cpp
@@ -1128,18 +1128,18 @@ TEST(SmallVectorTest, InitializerList) {
   SmallVector<int, 2> V1 = {};
   EXPECT_TRUE(V1.empty());
   V1 = {0, 0};
-  EXPECT_TRUE(makeArrayRef(V1).equals({0, 0}));
+  EXPECT_TRUE(ArrayRef(V1).equals({0, 0}));
   V1 = {-1, -1};
-  EXPECT_TRUE(makeArrayRef(V1).equals({-1, -1}));
+  EXPECT_TRUE(ArrayRef(V1).equals({-1, -1}));
 
   SmallVector<int, 2> V2 = {1, 2, 3, 4};
-  EXPECT_TRUE(makeArrayRef(V2).equals({1, 2, 3, 4}));
+  EXPECT_TRUE(ArrayRef(V2).equals({1, 2, 3, 4}));
   V2.assign({4});
-  EXPECT_TRUE(makeArrayRef(V2).equals({4}));
+  EXPECT_TRUE(ArrayRef(V2).equals({4}));
   V2.append({3, 2});
-  EXPECT_TRUE(makeArrayRef(V2).equals({4, 3, 2}));
+  EXPECT_TRUE(ArrayRef(V2).equals({4, 3, 2}));
   V2.insert(V2.begin() + 1, 5);
-  EXPECT_TRUE(makeArrayRef(V2).equals({4, 5, 3, 2}));
+  EXPECT_TRUE(ArrayRef(V2).equals({4, 5, 3, 2}));
 }
 
 TEST(SmallVectorTest, ToVector) {
diff --git a/llvm/unittests/ADT/TinyPtrVectorTest.cpp b/llvm/unittests/ADT/TinyPtrVectorTest.cpp
index b3c03cb..af4ae4f 100644
--- a/llvm/unittests/ADT/TinyPtrVectorTest.cpp
+++ b/llvm/unittests/ADT/TinyPtrVectorTest.cpp
@@ -53,9 +53,7 @@ protected:
 
   PtrT makePtr(ValueT *V) { return PtrT(V); }
 
-  ArrayRef<PtrT> testArray(size_t N) {
-    return makeArrayRef(&TestPtrs[0], N);
-  }
+  ArrayRef<PtrT> testArray(size_t N) { return ArrayRef(&TestPtrs[0], N); }
 
   void appendValues(VectorT &V, ArrayRef<PtrT> Values) {
     for (size_t i = 0, e = Values.size(); i != e; ++i)
diff --git a/llvm/unittests/Analysis/MemoryProfileInfoTest.cpp b/llvm/unittests/Analysis/MemoryProfileInfoTest.cpp
index be3b041..ffe822e 100644
--- a/llvm/unittests/Analysis/MemoryProfileInfoTest.cpp
+++ b/llvm/unittests/Analysis/MemoryProfileInfoTest.cpp
@@ -407,10 +407,10 @@ declare noundef nonnull ptr @_Znam(i64 noundef)
       StackIds.push_back(*ContextIter);
     if (First) {
       std::vector<uint64_t> Expected = {2, 3, 4};
-      EXPECT_EQ(makeArrayRef(StackIds), makeArrayRef(Expected));
+      EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
     } else {
       std::vector<uint64_t> Expected = {2, 3, 5};
-      EXPECT_EQ(makeArrayRef(StackIds), makeArrayRef(Expected));
+      EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
     }
     First = false;
   }
@@ -435,10 +435,10 @@ TEST_F(MemoryProfileInfoTest, CallStackTestSummary) {
       StackIds.push_back(Index->getStackIdAtIndex(StackIdIndex));
     if (First) {
       std::vector<uint64_t> Expected = {3, 4};
-      EXPECT_EQ(makeArrayRef(StackIds), makeArrayRef(Expected));
+      EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
     } else {
       std::vector<uint64_t> Expected = {3, 5};
-      EXPECT_EQ(makeArrayRef(StackIds), makeArrayRef(Expected));
+      EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
     }
     First = false;
   }
@@ -455,10 +455,10 @@ TEST_F(MemoryProfileInfoTest, CallStackTestSummary) {
         StackIds.push_back(Index->getStackIdAtIndex(StackIdIndex));
       if (First) {
         std::vector<uint64_t> Expected = {1, 2, 3, 4};
-        EXPECT_EQ(makeArrayRef(StackIds), makeArrayRef(Expected));
+        EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
       } else {
         std::vector<uint64_t> Expected = {1, 2, 3, 5};
-        EXPECT_EQ(makeArrayRef(StackIds), makeArrayRef(Expected));
+        EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
       }
       First = false;
     }
diff --git a/llvm/unittests/Analysis/VectorUtilsTest.cpp b/llvm/unittests/Analysis/VectorUtilsTest.cpp
index 6d08722..c7419e0 100644
--- a/llvm/unittests/Analysis/VectorUtilsTest.cpp
+++ b/llvm/unittests/Analysis/VectorUtilsTest.cpp
@@ -105,9 +105,10 @@ TEST_F(BasicTest, isSplat) {
 TEST_F(BasicTest, narrowShuffleMaskElts) {
   SmallVector<int, 16> ScaledMask;
   narrowShuffleMaskElts(1, {3,2,0,-2}, ScaledMask);
-  EXPECT_EQ(makeArrayRef(ScaledMask), makeArrayRef({3,2,0,-2}));
+  EXPECT_EQ(ArrayRef(ScaledMask), ArrayRef({3, 2, 0, -2}));
   narrowShuffleMaskElts(4, {3,2,0,-1}, ScaledMask);
-  EXPECT_EQ(makeArrayRef(ScaledMask), makeArrayRef({12,13,14,15,8,9,10,11,0,1,2,3,-1,-1,-1,-1}));
+  EXPECT_EQ(ArrayRef(ScaledMask), ArrayRef({12, 13, 14, 15, 8, 9, 10, 11, 0, 1,
+                                            2, 3, -1, -1, -1, -1}));
 }
 
 TEST_F(BasicTest, widenShuffleMaskElts) {
@@ -116,11 +117,11 @@ TEST_F(BasicTest, widenShuffleMaskElts) {
 
   // scale == 1 is a copy
   EXPECT_TRUE(widenShuffleMaskElts(1, {3,2,0,-1}, WideMask));
-  EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({3,2,0,-1}));
+  EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1}));
 
   // back to original mask
-  narrowShuffleMaskElts(1, makeArrayRef(WideMask), NarrowMask);
-  EXPECT_EQ(makeArrayRef(NarrowMask), makeArrayRef({3,2,0,-1}));
+  narrowShuffleMaskElts(1, ArrayRef(WideMask), NarrowMask);
+  EXPECT_EQ(ArrayRef(NarrowMask), ArrayRef({3, 2, 0, -1}));
 
   // can't widen non-consecutive 3/2
   EXPECT_FALSE(widenShuffleMaskElts(2, {3,2,0,-1}, WideMask));
@@ -130,30 +131,31 @@ TEST_F(BasicTest, widenShuffleMaskElts) {
 
   // can always widen identity to single element
   EXPECT_TRUE(widenShuffleMaskElts(3, {0,1,2}, WideMask));
-  EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({0}));
+  EXPECT_EQ(ArrayRef(WideMask), ArrayRef({0}));
 
   // back to original mask
-  narrowShuffleMaskElts(3, makeArrayRef(WideMask), NarrowMask);
-  EXPECT_EQ(makeArrayRef(NarrowMask), makeArrayRef({0,1,2}));
+  narrowShuffleMaskElts(3, ArrayRef(WideMask), NarrowMask);
+  EXPECT_EQ(ArrayRef(NarrowMask), ArrayRef({0, 1, 2}));
 
   // groups of 4 must be consecutive/undef
   EXPECT_TRUE(widenShuffleMaskElts(4, {12,13,14,15,8,9,10,11,0,1,2,3,-1,-1,-1,-1}, WideMask));
-  EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({3,2,0,-1}));
+  EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1}));
 
   // back to original mask
-  narrowShuffleMaskElts(4, makeArrayRef(WideMask), NarrowMask);
-  EXPECT_EQ(makeArrayRef(NarrowMask), makeArrayRef({12,13,14,15,8,9,10,11,0,1,2,3,-1,-1,-1,-1}));
+  narrowShuffleMaskElts(4, ArrayRef(WideMask), NarrowMask);
+  EXPECT_EQ(ArrayRef(NarrowMask), ArrayRef({12, 13, 14, 15, 8, 9, 10, 11, 0, 1,
+                                            2, 3, -1, -1, -1, -1}));
 
   // groups of 2 must be consecutive/undef
   EXPECT_FALSE(widenShuffleMaskElts(2, {12,12,14,15,8,9,10,11,0,1,2,3,-1,-1,-1,-1}, WideMask));
 
   // groups of 3 must be consecutive/undef
   EXPECT_TRUE(widenShuffleMaskElts(3, {6,7,8,0,1,2,-1,-1,-1}, WideMask));
-  EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({2,0,-1}));
+  EXPECT_EQ(ArrayRef(WideMask), ArrayRef({2, 0, -1}));
 
   // back to original mask
-  narrowShuffleMaskElts(3, makeArrayRef(WideMask), NarrowMask);
-  EXPECT_EQ(makeArrayRef(NarrowMask), makeArrayRef({6,7,8,0,1,2,-1,-1,-1}));
+  narrowShuffleMaskElts(3, ArrayRef(WideMask), NarrowMask);
+  EXPECT_EQ(ArrayRef(NarrowMask), ArrayRef({6, 7, 8, 0, 1, 2, -1, -1, -1}));
 
   // groups of 3 must be consecutive/undef (partial undefs are not ok)
   EXPECT_FALSE(widenShuffleMaskElts(3, {-1,7,8,0,-1,2,-1,-1,-1}, WideMask));
@@ -163,7 +165,7 @@ TEST_F(BasicTest, widenShuffleMaskElts) {
 
   // negative indexes must match across a wide element
   EXPECT_TRUE(widenShuffleMaskElts(2, {-2,-2,-3,-3}, WideMask));
-  EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({-2,-3}));
+  EXPECT_EQ(ArrayRef(WideMask), ArrayRef({-2, -3}));
 }
 
 TEST_F(BasicTest, getShuffleMaskWithWidestElts) {
@@ -171,43 +173,42 @@ TEST_F(BasicTest, getShuffleMaskWithWidestElts) {
 
   // can not widen anything here.
   getShuffleMaskWithWidestElts({3, 2, 0, -1}, WideMask);
-  EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({3, 2, 0, -1}));
+  EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1}));
 
   // can't widen non-consecutive 3/2
   getShuffleMaskWithWidestElts({3, 2, 0, -1}, WideMask);
-  EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({3, 2, 0, -1}));
+  EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1}));
 
   // can always widen identity to single element
   getShuffleMaskWithWidestElts({0, 1, 2}, WideMask);
-  EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({0}));
+  EXPECT_EQ(ArrayRef(WideMask), ArrayRef({0}));
 
   // groups of 4 must be consecutive/undef
   getShuffleMaskWithWidestElts(
       {12, 13, 14, 15, 8, 9, 10, 11, 0, 1, 2, 3, -1, -1, -1, -1}, WideMask);
-  EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({3, 2, 0, -1}));
+  EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1}));
 
   // groups of 2 must be consecutive/undef
   getShuffleMaskWithWidestElts(
       {12, 12, 14, 15, 8, 9, 10, 11, 0, 1, 2, 3, -1, -1, -1, -1}, WideMask);
-  EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({12, 12, 14, 15, 8, 9, 10, 11,
-                                                  0, 1, 2, 3, -1, -1, -1, -1}));
+  EXPECT_EQ(ArrayRef(WideMask), ArrayRef({12, 12, 14, 15, 8, 9, 10, 11, 0, 1, 2,
+                                          3, -1, -1, -1, -1}));
 
   // groups of 3 must be consecutive/undef
   getShuffleMaskWithWidestElts({6, 7, 8, 0, 1, 2, -1, -1, -1}, WideMask);
-  EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({2, 0, -1}));
+  EXPECT_EQ(ArrayRef(WideMask), ArrayRef({2, 0, -1}));
 
   // groups of 3 must be consecutive/undef (partial undefs are not ok)
   getShuffleMaskWithWidestElts({-1, 7, 8, 0, -1, 2, -1, -1, -1}, WideMask);
-  EXPECT_EQ(makeArrayRef(WideMask),
-            makeArrayRef({-1, 7, 8, 0, -1, 2, -1, -1, -1}));
+  EXPECT_EQ(ArrayRef(WideMask), ArrayRef({-1, 7, 8, 0, -1, 2, -1, -1, -1}));
 
   // negative indexes must match across a wide element
   getShuffleMaskWithWidestElts({-1, -2, -1, -1}, WideMask);
-  EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({-1, -2, -1, -1}));
+  EXPECT_EQ(ArrayRef(WideMask), ArrayRef({-1, -2, -1, -1}));
 
   // negative indexes must match across a wide element
   getShuffleMaskWithWidestElts({-2, -2, -3, -3}, WideMask);
-  EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({-2, -3}));
+  EXPECT_EQ(ArrayRef(WideMask), ArrayRef({-2, -3}));
 }
 
 TEST_F(BasicTest, getShuffleDemandedElts) {
diff --git a/llvm/unittests/Bitstream/BitstreamReaderTest.cpp b/llvm/unittests/Bitstream/BitstreamReaderTest.cpp
index f9056f0..0686ac4 100644
--- a/llvm/unittests/Bitstream/BitstreamReaderTest.cpp
+++ b/llvm/unittests/Bitstream/BitstreamReaderTest.cpp
@@ -108,7 +108,7 @@ TEST(BitstreamReaderTest, readRecordWithBlobWhileStreaming) {
       Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
       AbbrevID = Stream.EmitAbbrev(std::move(Abbrev));
       unsigned Record[] = {RecordID};
-      Stream.EmitRecordWithBlob(AbbrevID, makeArrayRef(Record), BlobIn);
+      Stream.EmitRecordWithBlob(AbbrevID, ArrayRef(Record), BlobIn);
 
       Stream.ExitBlock();
     }
diff --git a/llvm/unittests/DebugInfo/MSF/MappedBlockStreamTest.cpp b/llvm/unittests/DebugInfo/MSF/MappedBlockStreamTest.cpp
index 588d51a..60fb14d 100644
--- a/llvm/unittests/DebugInfo/MSF/MappedBlockStreamTest.cpp
+++ b/llvm/unittests/DebugInfo/MSF/MappedBlockStreamTest.cpp
@@ -493,7 +493,7 @@ TEST(MappedBlockStreamTest, DataLivesAfterStreamDestruction) {
 
 MATCHER_P3(BlockIsFilledWith, Layout, BlockIndex, Byte, "succeeded") {
   uint64_t Offset = msf::blockToOffset(BlockIndex, Layout.SB->BlockSize);
-  ArrayRef<uint8_t> BufferRef = makeArrayRef(arg);
+  ArrayRef<uint8_t> BufferRef = ArrayRef(arg);
   BufferRef = BufferRef.slice(Offset, Layout.SB->BlockSize);
   return llvm::all_of(BufferRef, [this](uint8_t B) { return B == Byte; });
 }
diff --git a/llvm/unittests/FuzzMutate/RandomIRBuilderTest.cpp b/llvm/unittests/FuzzMutate/RandomIRBuilderTest.cpp
index 45ba42e..bc1d60e 100644
--- a/llvm/unittests/FuzzMutate/RandomIRBuilderTest.cpp
+++ b/llvm/unittests/FuzzMutate/RandomIRBuilderTest.cpp
@@ -302,7 +302,7 @@ TEST(RandomIRBuilderTest, dontConnectToSwitch) {
     // Choose an instruction and connect to later operations.
     size_t IP = uniform<size_t>(IB.Rand, 1, Insts.size() - 1);
     Instruction *Inst = Insts[IP - 1];
-    auto ConnectAfter = makeArrayRef(Insts).slice(IP);
+    auto ConnectAfter = ArrayRef(Insts).slice(IP);
     IB.connectToSink(*BB, ConnectAfter, Inst);
     ASSERT_FALSE(verifyModule(*M, &errs()));
   }
diff --git a/llvm/unittests/IR/AttributesTest.cpp b/llvm/unittests/IR/AttributesTest.cpp
index 832af6e..fcd7a22 100644
--- a/llvm/unittests/IR/AttributesTest.cpp
+++ b/llvm/unittests/IR/AttributesTest.cpp
@@ -201,9 +201,9 @@ TEST(Attributes, HasParentContext) {
 
   {
     AttributeSet AS1 = AttributeSet::get(
-        C1, makeArrayRef(Attribute::get(C1, Attribute::NoReturn)));
+        C1, ArrayRef(Attribute::get(C1, Attribute::NoReturn)));
     AttributeSet AS2 = AttributeSet::get(
-        C2, makeArrayRef(Attribute::get(C2, Attribute::NoReturn)));
+        C2, ArrayRef(Attribute::get(C2, Attribute::NoReturn)));
     EXPECT_TRUE(AS1.hasParentContext(C1));
     EXPECT_FALSE(AS1.hasParentContext(C2));
     EXPECT_FALSE(AS2.hasParentContext(C1));
diff --git a/llvm/unittests/IR/DebugInfoTest.cpp b/llvm/unittests/IR/DebugInfoTest.cpp
index 8a5157f..8e504d5 100644
--- a/llvm/unittests/IR/DebugInfoTest.cpp
+++ b/llvm/unittests/IR/DebugInfoTest.cpp
@@ -84,7 +84,7 @@ TEST(DINodeTest, splitFlags) {
   {                                                                            \
     SmallVector<DINode::DIFlags, 8> V;                                         \
     EXPECT_EQ(REMAINDER, DINode::splitFlags(FLAGS, V));                        \
-    EXPECT_TRUE(makeArrayRef(V).equals(VECTOR));                               \
+    EXPECT_TRUE(ArrayRef(V).equals(VECTOR));                                   \
   }
   CHECK_SPLIT(DINode::FlagPublic, {DINode::FlagPublic}, DINode::FlagZero);
   CHECK_SPLIT(DINode::FlagProtected, {DINode::FlagProtected}, DINode::FlagZero);
diff --git a/llvm/unittests/IR/MetadataTest.cpp b/llvm/unittests/IR/MetadataTest.cpp
index 926490f..f8a796a 100644
--- a/llvm/unittests/IR/MetadataTest.cpp
+++ b/llvm/unittests/IR/MetadataTest.cpp
@@ -2931,7 +2931,7 @@ typedef MetadataTest DIExpressionTest;
 TEST_F(DIExpressionTest, get) {
   uint64_t Elements[] = {2, 6, 9, 78, 0};
   auto *N = DIExpression::get(Context, Elements);
-  EXPECT_EQ(makeArrayRef(Elements), N->getElements());
+  EXPECT_EQ(ArrayRef(Elements), N->getElements());
   EXPECT_EQ(N, DIExpression::get(Context, Elements));
 
   EXPECT_EQ(5u, N->getNumElements());
diff --git a/llvm/unittests/Object/ELFTypesTest.cpp b/llvm/unittests/Object/ELFTypesTest.cpp
index 183ef3e..265f8a7 100644
--- a/llvm/unittests/Object/ELFTypesTest.cpp
+++ b/llvm/unittests/Object/ELFTypesTest.cpp
@@ -43,7 +43,7 @@ template <class ELFT> struct NoteTestData {
 
 TEST(ELFTypesTest, NoteTest) {
   static const uint8_t Random[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
-  ArrayRef<uint8_t> RandomData = makeArrayRef(Random);
+  ArrayRef<uint8_t> RandomData = ArrayRef(Random);
   NoteTestData<ELF64LE> TestData;
 
   auto Note1 = TestData.getElfNote(StringRef("AMD"), ELF::NT_AMDGPU_METADATA,
diff --git a/llvm/unittests/ObjectYAML/MinidumpYAMLTest.cpp b/llvm/unittests/ObjectYAML/MinidumpYAMLTest.cpp
index a3c9e7e..0297f62 100644
--- a/llvm/unittests/ObjectYAML/MinidumpYAMLTest.cpp
+++ b/llvm/unittests/ObjectYAML/MinidumpYAMLTest.cpp
@@ -137,7 +137,7 @@ Streams:
   EXPECT_EQ(OSPlatform::Linux, SysInfo.PlatformId);
   EXPECT_EQ(
       (ArrayRef<uint8_t>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}),
-      makeArrayRef(SysInfo.CPU.Other.ProcessorFeatures));
+      ArrayRef(SysInfo.CPU.Other.ProcessorFeatures));
 }
 
 // Test that we can parse a normal-looking ExceptionStream.
diff --git a/llvm/unittests/ProfileData/CoverageMappingTest.cpp b/llvm/unittests/ProfileData/CoverageMappingTest.cpp
index 2791f678..884a76c 100644
--- a/llvm/unittests/ProfileData/CoverageMappingTest.cpp
+++ b/llvm/unittests/ProfileData/CoverageMappingTest.cpp
@@ -213,7 +213,7 @@ struct CoverageMappingTest : ::testing::TestWithParam<std::tuple<bool, bool>> {
     Filenames.resize(Files.size() + 1);
     for (const auto &E : Files)
       Filenames[E.getValue()] = E.getKey().str();
-    ArrayRef<std::string> FilenameRefs = llvm::makeArrayRef(Filenames);
+    ArrayRef<std::string> FilenameRefs = llvm::ArrayRef(Filenames);
     RawCoverageMappingReader Reader(Coverage, FilenameRefs, Data.Filenames,
                                     Data.Expressions, Data.Regions);
     EXPECT_THAT_ERROR(Reader.read(), Succeeded());
@@ -279,7 +279,7 @@ TEST_P(CoverageMappingTest, basic_write_read) {
   InputFunctionCoverageData &Input = InputFunctions.back();
   OutputFunctionCoverageData &Output = OutputFunctions.back();
 
-  size_t N = makeArrayRef(Input.Regions).size();
+  size_t N = ArrayRef(Input.Regions).size();
   ASSERT_EQ(N, Output.Regions.size());
   for (size_t I = 0; I < N; ++I) {
     ASSERT_EQ(Input.Regions[I].Count, Output.Regions[I].Count);
diff --git a/llvm/unittests/ProfileData/InstrProfTest.cpp b/llvm/unittests/ProfileData/InstrProfTest.cpp
index cbc04d2..86a7047 100644
--- a/llvm/unittests/ProfileData/InstrProfTest.cpp
+++ b/llvm/unittests/ProfileData/InstrProfTest.cpp
@@ -551,7 +551,7 @@ TEST_P(MaybeSparseInstrProfTest, annotate_vp_data) {
   // Annotate with 4 records.
   InstrProfValueData VD0Sorted[] = {{1000, 6}, {2000, 5}, {3000, 4}, {4000, 3},
                               {5000, 2}, {6000, 1}};
-  annotateValueSite(*M, *Inst, makeArrayRef(VD0Sorted).slice(2), 10,
+  annotateValueSite(*M, *Inst, ArrayRef(VD0Sorted).slice(2), 10,
                     IPVK_IndirectCallTarget, 5);
   Res = getValueProfDataFromInst(*Inst, IPVK_IndirectCallTarget, 5,
                                       ValueData, N, T);
diff --git a/llvm/unittests/Remarks/YAMLRemarksSerializerTest.cpp b/llvm/unittests/Remarks/YAMLRemarksSerializerTest.cpp
index fef1a93..442c24b 100644
--- a/llvm/unittests/Remarks/YAMLRemarksSerializerTest.cpp
+++ b/llvm/unittests/Remarks/YAMLRemarksSerializerTest.cpp
@@ -55,7 +55,7 @@ static void check(remarks::Format SerializerFormat, const remarks::Remark &R,
                   StringRef ExpectedR, StringRef ExpectedMeta,
                   std::optional<remarks::StringTable> StrTab = std::nullopt) {
   return check(SerializerFormat, remarks::SerializerMode::Separate,
-               makeArrayRef(&R, &R + 1), ExpectedR, ExpectedMeta,
+               ArrayRef(&R, &R + 1), ExpectedR, ExpectedMeta,
                std::move(StrTab));
 }
 
@@ -64,7 +64,7 @@ checkStandalone(remarks::Format SerializerFormat, const remarks::Remark &R,
                 StringRef ExpectedR,
                 std::optional<remarks::StringTable> StrTab = std::nullopt) {
   return check(SerializerFormat, remarks::SerializerMode::Standalone,
-               makeArrayRef(&R, &R + 1), ExpectedR,
+               ArrayRef(&R, &R + 1), ExpectedR,
                /*ExpectedMeta=*/std::nullopt, std::move(StrTab));
 }
 
diff --git a/llvm/unittests/Support/BinaryStreamTest.cpp b/llvm/unittests/Support/BinaryStreamTest.cpp
index fdd29a7..01b49ca 100644
--- a/llvm/unittests/Support/BinaryStreamTest.cpp
+++ b/llvm/unittests/Support/BinaryStreamTest.cpp
@@ -46,7 +46,7 @@ public:
     uint8_t *Ptr = Allocator.Allocate<uint8_t>(Size);
     ::memcpy(Ptr, Ref.data(), Ref.size());
     ::memcpy(Ptr + Ref.size(), Data.data(), BytesLeft);
-    Buffer = makeArrayRef<uint8_t>(Ptr, Size);
+    Buffer = ArrayRef<uint8_t>(Ptr, Size);
     return Error::success();
   }
 
@@ -203,9 +203,9 @@ TEST_F(BinaryStreamTest, BinaryByteStreamBounds) {
     // 1. If the read fits it should work.
     ASSERT_EQ(InputData.size(), Stream.Input->getLength());
     ASSERT_THAT_ERROR(Stream.Input->readBytes(2, 1, Buffer), Succeeded());
-    EXPECT_EQ(makeArrayRef(InputData).slice(2, 1), Buffer);
+    EXPECT_EQ(ArrayRef(InputData).slice(2, 1), Buffer);
     ASSERT_THAT_ERROR(Stream.Input->readBytes(0, 4, Buffer), Succeeded());
-    EXPECT_EQ(makeArrayRef(InputData).slice(0, 4), Buffer);
+    EXPECT_EQ(ArrayRef(InputData).slice(0, 4), Buffer);
 
     // 2. Reading past the bounds of the input should fail.
     EXPECT_THAT_ERROR(Stream.Input->readBytes(4, 2, Buffer), Failed());
@@ -223,12 +223,12 @@ TEST_F(BinaryStreamTest, StreamRefBounds) {
     // Read 1 byte from offset 2 should work
     ASSERT_EQ(InputData.size(), Ref.getLength());
     ASSERT_THAT_ERROR(Ref.readBytes(2, 1, Buffer), Succeeded());
-    EXPECT_EQ(makeArrayRef(InputData).slice(2, 1), Buffer);
+    EXPECT_EQ(ArrayRef(InputData).slice(2, 1), Buffer);
 
     // Reading everything from offset 2 on.
     ASSERT_THAT_ERROR(Ref.readLongestContiguousChunk(2, Buffer), Succeeded());
     if (Stream.IsContiguous)
-      EXPECT_EQ(makeArrayRef(InputData).slice(2), Buffer);
+      EXPECT_EQ(ArrayRef(InputData).slice(2), Buffer);
     else
       EXPECT_FALSE(Buffer.empty());
 
@@ -241,14 +241,14 @@ TEST_F(BinaryStreamTest, StreamRefBounds) {
     Ref = Ref.drop_front(1);
     ASSERT_THAT_ERROR(Ref.readBytes(2, 1, Buffer), Succeeded());
     if (Stream.IsContiguous)
-      EXPECT_EQ(makeArrayRef(InputData).slice(3, 1), Buffer);
+      EXPECT_EQ(ArrayRef(InputData).slice(3, 1), Buffer);
     else
       EXPECT_FALSE(Buffer.empty());
 
     // Reading everything from offset 2 on after dropping 1 byte.
     ASSERT_THAT_ERROR(Ref.readLongestContiguousChunk(2, Buffer), Succeeded());
     if (Stream.IsContiguous)
-      EXPECT_EQ(makeArrayRef(InputData).slice(3), Buffer);
+      EXPECT_EQ(ArrayRef(InputData).slice(3), Buffer);
     else
       EXPECT_FALSE(Buffer.empty());
 
@@ -260,7 +260,7 @@ TEST_F(BinaryStreamTest, StreamRefBounds) {
     // But if we read the longest contiguous chunk instead, we should still
     // get the 1 byte at the end.
     ASSERT_THAT_ERROR(Ref.readLongestContiguousChunk(2, Buffer), Succeeded());
-    EXPECT_EQ(makeArrayRef(InputData).take_back(), Buffer);
+    EXPECT_EQ(ArrayRef(InputData).take_back(), Buffer);
   }
 }
 
@@ -316,7 +316,7 @@ TEST_F(BinaryStreamTest, StreamRefDynamicSize) {
 
 TEST_F(BinaryStreamTest, DropOperations) {
   std::vector<uint8_t> InputData = {1, 2, 3, 4, 5, 4, 3, 2, 1};
-  auto RefData = makeArrayRef(InputData);
+  auto RefData = ArrayRef(InputData);
   initializeInput(InputData, 1);
 
   ArrayRef<uint8_t> Result;
@@ -383,7 +383,7 @@ TEST_F(BinaryStreamTest, MutableBinaryByteStreamBounds) {
       ArrayRef<uint8_t> Data2;
       ASSERT_THAT_ERROR(Stream.Output->readBytes(Offset, ExpectedSize, Data2),
                         Succeeded());
-      EXPECT_EQ(makeArrayRef(InputData).drop_front(Offset), Data2);
+      EXPECT_EQ(ArrayRef(InputData).drop_front(Offset), Data2);
     }
 
     std::vector<uint8_t> BigData = {0, 1, 2, 3, 4};
@@ -397,7 +397,7 @@ TEST_F(BinaryStreamTest, AppendingStream) {
   EXPECT_EQ(0U, Stream.getLength());
 
   std::vector<uint8_t> InputData = {'T', 'e', 's', 't', 'T', 'e', 's', 't'};
-  auto Test = makeArrayRef(InputData).take_front(4);
+  auto Test = ArrayRef(InputData).take_front(4);
   // Writing past the end of the stream is an error.
   EXPECT_THAT_ERROR(Stream.writeBytes(4, Test), Failed());
 
@@ -575,7 +575,7 @@ TEST_F(BinaryStreamTest, StreamReaderIntegerArray) {
     ArrayRef<int> IntsRef;
     ASSERT_THAT_ERROR(Reader.readArray(IntsRef, Ints.size()), Succeeded());
     ASSERT_EQ(0U, Reader.bytesRemaining());
-    EXPECT_EQ(makeArrayRef(Ints), IntsRef);
+    EXPECT_EQ(ArrayRef(Ints), IntsRef);
 
     Reader.setOffset(0);
     FixedStreamArray<int> FixedIntsRef;
@@ -699,7 +699,7 @@ TEST_F(BinaryStreamTest, StreamReaderObject) {
 
   const uint8_t *Bytes = reinterpret_cast<const uint8_t *>(&Foos[0]);
 
-  initializeInput(makeArrayRef(Bytes, 3 * sizeof(Foo)), alignof(Foo));
+  initializeInput(ArrayRef(Bytes, 3 * sizeof(Foo)), alignof(Foo));
 
   for (auto &Stream : Streams) {
     // 1. Reading object pointers.
@@ -803,7 +803,7 @@ TEST_F(BinaryStreamTest, StreamWriterIntegerArrays) {
     ASSERT_THAT_ERROR(ReaderBacker.readArray(Ints2, SourceInts.size()),
                       Succeeded());
 
-    EXPECT_EQ(makeArrayRef(SourceInts), Ints2);
+    EXPECT_EQ(ArrayRef(SourceInts), Ints2);
   }
 }
 
@@ -827,7 +827,7 @@ TEST_F(BinaryStreamTest, StreamWriterStrings) {
       ASSERT_THAT_ERROR(Reader.readCString(S), Succeeded());
       InStrings.push_back(S);
     }
-    EXPECT_EQ(makeArrayRef(Strings), makeArrayRef(InStrings));
+    EXPECT_EQ(ArrayRef(Strings), ArrayRef(InStrings));
   }
 }
 
diff --git a/llvm/unittests/Support/CRCTest.cpp b/llvm/unittests/Support/CRCTest.cpp
index 32d2cf7..fb6dbc7 100644
--- a/llvm/unittests/Support/CRCTest.cpp
+++ b/llvm/unittests/Support/CRCTest.cpp
@@ -55,7 +55,7 @@ TEST(CRCTest, LargeCRC32) {
   // Test expectation generated with:
   // $ truncate --size=`echo 2^32-1+42 | bc` /tmp/foo
   // $ crc32 /tmp/foo
-  EXPECT_EQ(0xE46F28FBU, llvm::crc32(makeArrayRef(TestData, TestSize)));
+  EXPECT_EQ(0xE46F28FBU, llvm::crc32(ArrayRef(TestData, TestSize)));
 
   free(TestData);
 }
diff --git a/llvm/unittests/Support/CommandLineTest.cpp b/llvm/unittests/Support/CommandLineTest.cpp
index 0d0b6ec..b65d4bd 100644
--- a/llvm/unittests/Support/CommandLineTest.cpp
+++ b/llvm/unittests/Support/CommandLineTest.cpp
@@ -436,7 +436,7 @@ TEST(CommandLineTest, HideUnrelatedOptionsMulti) {
   const cl::OptionCategory *VisibleCategories[] = {&TestCategory,
                                                    &TestCategory2};
 
-  cl::HideUnrelatedOptions(makeArrayRef(VisibleCategories));
+  cl::HideUnrelatedOptions(ArrayRef(VisibleCategories));
 
   ASSERT_EQ(cl::ReallyHidden, TestOption1.getOptionHiddenFlag())
       << "Failed to hide extra option.";
diff --git a/llvm/unittests/Support/ConvertUTFTest.cpp b/llvm/unittests/Support/ConvertUTFTest.cpp
index 8f172b7..6e75fba 100644
--- a/llvm/unittests/Support/ConvertUTFTest.cpp
+++ b/llvm/unittests/Support/ConvertUTFTest.cpp
@@ -75,7 +75,7 @@ TEST(ConvertUTFTest, ConvertUTF8ToUTF16String) {
 
 TEST(ConvertUTFTest, OddLengthInput) {
   std::string Result;
-  bool Success = convertUTF16ToUTF8String(makeArrayRef("xxxxx", 5), Result);
+  bool Success = convertUTF16ToUTF8String(ArrayRef("xxxxx", 5), Result);
   EXPECT_FALSE(Success);
 }
 
@@ -88,25 +88,25 @@ TEST(ConvertUTFTest, Empty) {
 }
 
 TEST(ConvertUTFTest, HasUTF16BOM) {
-  bool HasBOM = hasUTF16ByteOrderMark(makeArrayRef("\xff\xfe", 2));
+  bool HasBOM = hasUTF16ByteOrderMark(ArrayRef("\xff\xfe", 2));
   EXPECT_TRUE(HasBOM);
-  HasBOM = hasUTF16ByteOrderMark(makeArrayRef("\xfe\xff", 2));
+  HasBOM = hasUTF16ByteOrderMark(ArrayRef("\xfe\xff", 2));
   EXPECT_TRUE(HasBOM);
-  HasBOM = hasUTF16ByteOrderMark(makeArrayRef("\xfe\xff ", 3));
+  HasBOM = hasUTF16ByteOrderMark(ArrayRef("\xfe\xff ", 3));
   EXPECT_TRUE(HasBOM); // Don't care about odd lengths.
-  HasBOM = hasUTF16ByteOrderMark(makeArrayRef("\xfe\xff\x00asdf", 6));
+  HasBOM = hasUTF16ByteOrderMark(ArrayRef("\xfe\xff\x00asdf", 6));
   EXPECT_TRUE(HasBOM);
 
   HasBOM = hasUTF16ByteOrderMark(std::nullopt);
   EXPECT_FALSE(HasBOM);
-  HasBOM = hasUTF16ByteOrderMark(makeArrayRef("\xfe", 1));
+  HasBOM = hasUTF16ByteOrderMark(ArrayRef("\xfe", 1));
   EXPECT_FALSE(HasBOM);
 }
 
 TEST(ConvertUTFTest, UTF16WrappersForConvertUTF16ToUTF8String) {
   // Src is the look of disapproval.
   alignas(UTF16) static const char Src[] = "\xff\xfe\xa0\x0c_\x00\xa0\x0c";
-  ArrayRef<UTF16> SrcRef = makeArrayRef((const UTF16 *)Src, 4);
+  ArrayRef<UTF16> SrcRef = ArrayRef((const UTF16 *)Src, 4);
   std::string Result;
   bool Success = convertUTF16ToUTF8String(SrcRef, Result);
   EXPECT_TRUE(Success);
diff --git a/llvm/unittests/Support/HashBuilderTest.cpp b/llvm/unittests/Support/HashBuilderTest.cpp
index 2e27e4b..65d5146 100644
--- a/llvm/unittests/Support/HashBuilderTest.cpp
+++ b/llvm/unittests/Support/HashBuilderTest.cpp
@@ -102,7 +102,7 @@ TYPED_TEST(HashBuilderTest, AddHashableData) {
     constexpr auto E = HE::Endianness;
     H Hasher;
     auto SwappedData = llvm::support::endian::byte_swap(Data, E);
-    Hasher.update(llvm::makeArrayRef(
+    Hasher.update(llvm::ArrayRef(
         reinterpret_cast<const uint8_t *>(&SwappedData), sizeof(Data)));
     return Hasher.final();
   };
@@ -157,8 +157,8 @@ struct /* __attribute__((packed)) */ StructWithFastHash {
   friend void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder,
                       const StructWithFastHash &Value) {
     if (Endianness == llvm::support::endian::system_endianness()) {
-      HBuilder.update(llvm::makeArrayRef(
-          reinterpret_cast<const uint8_t *>(&Value), sizeof(Value)));
+      HBuilder.update(llvm::ArrayRef(reinterpret_cast<const uint8_t *>(&Value),
+                                     sizeof(Value)));
     } else {
       // Rely on existing `add` methods to handle endianness.
       HBuilder.add(Value.I);
@@ -181,7 +181,7 @@ public:
   friend void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder,
                       const CustomContainer &Value) {
     if (Endianness == llvm::support::endian::system_endianness()) {
-      HBuilder.update(llvm::makeArrayRef(
+      HBuilder.update(llvm::ArrayRef(
           reinterpret_cast<const uint8_t *>(&Value.Size),
           sizeof(Value.Size) + Value.Size * sizeof(Value.Elements[0])));
     } else {
diff --git a/llvm/unittests/Support/IndexedAccessorTest.cpp b/llvm/unittests/Support/IndexedAccessorTest.cpp
index 02b5656..99986de 100644
--- a/llvm/unittests/Support/IndexedAccessorTest.cpp
+++ b/llvm/unittests/Support/IndexedAccessorTest.cpp
@@ -39,7 +39,7 @@ static void compareData(ArrayIndexedAccessorRange<T> range,
 namespace {
 TEST(AccessorRange, SliceTest) {
   int rawData[] = {0, 1, 2, 3, 4};
-  ArrayRef<int> data = llvm::makeArrayRef(rawData);
+  ArrayRef<int> data = llvm::ArrayRef(rawData);
 
   ArrayIndexedAccessorRange<int> range(rawData, /*start=*/0, /*numElements=*/5);
   compareData(range, data);
diff --git a/llvm/unittests/Support/MD5Test.cpp b/llvm/unittests/Support/MD5Test.cpp
index 83c556c..9742e1b 100644
--- a/llvm/unittests/Support/MD5Test.cpp
+++ b/llvm/unittests/Support/MD5Test.cpp
@@ -40,20 +40,20 @@ void TestMD5Sum(StringRef Input, StringRef Final) {
 }
 
 TEST(MD5Test, MD5) {
-  TestMD5Sum(makeArrayRef((const uint8_t *)"", (size_t) 0),
+  TestMD5Sum(ArrayRef((const uint8_t *)"", (size_t)0),
              "d41d8cd98f00b204e9800998ecf8427e");
-  TestMD5Sum(makeArrayRef((const uint8_t *)"a", (size_t) 1),
+  TestMD5Sum(ArrayRef((const uint8_t *)"a", (size_t)1),
              "0cc175b9c0f1b6a831c399e269772661");
-  TestMD5Sum(makeArrayRef((const uint8_t *)"abcdefghijklmnopqrstuvwxyz",
-                          (size_t) 26),
-             "c3fcd3d76192e4007dfb496cca67e13b");
-  TestMD5Sum(makeArrayRef((const uint8_t *)"\0", (size_t) 1),
+  TestMD5Sum(
+      ArrayRef((const uint8_t *)"abcdefghijklmnopqrstuvwxyz", (size_t)26),
+      "c3fcd3d76192e4007dfb496cca67e13b");
+  TestMD5Sum(ArrayRef((const uint8_t *)"\0", (size_t)1),
              "93b885adfe0da089cdf634904fd59f71");
-  TestMD5Sum(makeArrayRef((const uint8_t *)"a\0", (size_t) 2),
+  TestMD5Sum(ArrayRef((const uint8_t *)"a\0", (size_t)2),
              "4144e195f46de78a3623da7364d04f11");
-  TestMD5Sum(makeArrayRef((const uint8_t *)"abcdefghijklmnopqrstuvwxyz\0",
-                          (size_t) 27),
-             "81948d1f1554f58cd1a56ebb01f808cb");
+  TestMD5Sum(
+      ArrayRef((const uint8_t *)"abcdefghijklmnopqrstuvwxyz\0", (size_t)27),
+      "81948d1f1554f58cd1a56ebb01f808cb");
   TestMD5Sum("abcdefghijklmnopqrstuvwxyz", "c3fcd3d76192e4007dfb496cca67e13b");
 }
 
diff --git a/llvm/unittests/Support/ScopedPrinterTest.cpp b/llvm/unittests/Support/ScopedPrinterTest.cpp
index d959720..5afb796 100644
--- a/llvm/unittests/Support/ScopedPrinterTest.cpp
+++ b/llvm/unittests/Support/ScopedPrinterTest.cpp
@@ -226,8 +226,8 @@ TEST_F(ScopedPrinterTest, PrintEnum) {
                                        {"Name3", "AltName3", 3},
                                        {"Name4", "AltName4", 2}};
     EnumEntry<int> OtherEnum{"Name5", "AltName5", 5};
-    W.printEnum("Exists", EnumList[1].Value, makeArrayRef(EnumList));
-    W.printEnum("DoesNotExist", OtherEnum.Value, makeArrayRef(EnumList));
+    W.printEnum("Exists", EnumList[1].Value, ArrayRef(EnumList));
+    W.printEnum("DoesNotExist", OtherEnum.Value, ArrayRef(EnumList));
   };
 
   const char *ExpectedOut = R"(Exists: Name2 (0x2)
@@ -259,11 +259,10 @@ TEST_F(ScopedPrinterTest, PrintFlag) {
         {"SecondByte2", "Second2", 0x20u}, {"SecondByte3", "Second3", 0x30u},
         {"ThirdByte1", "Third1", 0x100u},  {"ThirdByte2", "Third2", 0x200u},
         {"ThirdByte3", "Third3", 0x300u}};
-    W.printFlags("ZeroFlag", 0, makeArrayRef(SingleBitFlags));
-    W.printFlags("NoFlag", 1 << 3, makeArrayRef(SingleBitFlags));
-    W.printFlags("Flag1", SingleBitFlags[1].Value,
-                 makeArrayRef(SingleBitFlags));
-    W.printFlags("Flag1&3", (1 << 2) + 1, makeArrayRef(SingleBitFlags));
+    W.printFlags("ZeroFlag", 0, ArrayRef(SingleBitFlags));
+    W.printFlags("NoFlag", 1 << 3, ArrayRef(SingleBitFlags));
+    W.printFlags("Flag1", SingleBitFlags[1].Value, ArrayRef(SingleBitFlags));
+    W.printFlags("Flag1&3", (1 << 2) + 1, ArrayRef(SingleBitFlags));
 
     W.printFlags("ZeroFlagRaw", 0);
     W.printFlags("NoFlagRaw", 1 << 3);
@@ -271,21 +270,19 @@ TEST_F(ScopedPrinterTest, PrintFlag) {
     W.printFlags("Flag1&3Raw", (1 << 2) + 1);
 
     W.printFlags("FlagSorted", (1 << 2) + (1 << 1) + 1,
-                 makeArrayRef(UnsortedFlags));
+                 ArrayRef(UnsortedFlags));
 
     uint16_t NoBitMask = 0;
     uint16_t FirstByteMask = 0xFu;
     uint16_t SecondByteMask = 0xF0u;
     uint16_t ThirdByteMask = 0xF00u;
-    W.printFlags("NoBitMask", 0xFFFu, makeArrayRef(EnumFlags), NoBitMask);
-    W.printFlags("FirstByteMask", 0x3u, makeArrayRef(EnumFlags), FirstByteMask);
-    W.printFlags("SecondByteMask", 0x30u, makeArrayRef(EnumFlags),
-                 SecondByteMask);
-    W.printFlags("ValueOutsideMask", 0x1u, makeArrayRef(EnumFlags),
-                 SecondByteMask);
-    W.printFlags("FirstSecondByteMask", 0xFFu, makeArrayRef(EnumFlags),
+    W.printFlags("NoBitMask", 0xFFFu, ArrayRef(EnumFlags), NoBitMask);
+    W.printFlags("FirstByteMask", 0x3u, ArrayRef(EnumFlags), FirstByteMask);
+    W.printFlags("SecondByteMask", 0x30u, ArrayRef(EnumFlags), SecondByteMask);
+    W.printFlags("ValueOutsideMask", 0x1u, ArrayRef(EnumFlags), SecondByteMask);
+    W.printFlags("FirstSecondByteMask", 0xFFu, ArrayRef(EnumFlags),
                  FirstByteMask, SecondByteMask);
-    W.printFlags("FirstSecondThirdByteMask", 0x333u, makeArrayRef(EnumFlags),
+    W.printFlags("FirstSecondThirdByteMask", 0x333u, ArrayRef(EnumFlags),
                  FirstByteMask, SecondByteMask, ThirdByteMask);
   };
 
@@ -662,7 +659,7 @@ TEST_F(ScopedPrinterTest, PrintList) {
                                             APSInt("-9999999999999999999999")};
     W.printList("EmptyList", EmptyList);
     W.printList("StringList", StringList);
-    W.printList("BoolList", makeArrayRef(BoolList));
+    W.printList("BoolList", ArrayRef(BoolList));
     W.printList("uint64List", Unsigned64List);
     W.printList("uint32List", Unsigned32List);
     W.printList("uint16List", Unsigned16List);
diff --git a/llvm/unittests/Support/SourceMgrTest.cpp b/llvm/unittests/Support/SourceMgrTest.cpp
index 1cce649..cbd17ff 100644
--- a/llvm/unittests/Support/SourceMgrTest.cpp
+++ b/llvm/unittests/Support/SourceMgrTest.cpp
@@ -511,7 +511,7 @@ TEST_F(SourceMgrTest, OverlappingRanges) {
 TEST_F(SourceMgrTest, BasicFixit) {
   setMainBuffer("aaa bbb\nccc ddd\n", "file.in");
   printMessage(getLoc(4), SourceMgr::DK_Error, "message", std::nullopt,
-               makeArrayRef(SMFixIt(getRange(4, 3), "zzz")));
+               ArrayRef(SMFixIt(getRange(4, 3), "zzz")));
 
   EXPECT_EQ("file.in:1:5: error: message\n"
             "aaa bbb\n"
@@ -523,7 +523,7 @@ TEST_F(SourceMgrTest, BasicFixit) {
 TEST_F(SourceMgrTest, FixitForTab) {
   setMainBuffer("aaa\tbbb\nccc ddd\n", "file.in");
   printMessage(getLoc(3), SourceMgr::DK_Error, "message", std::nullopt,
-               makeArrayRef(SMFixIt(getRange(3, 1), "zzz")));
+               ArrayRef(SMFixIt(getRange(3, 1), "zzz")));
 
   EXPECT_EQ("file.in:1:4: error: message\n"
             "aaa     bbb\n"
diff --git a/llvm/unittests/TableGen/AutomataTest.cpp b/llvm/unittests/TableGen/AutomataTest.cpp
index fb19716..53f6612 100644
--- a/llvm/unittests/TableGen/AutomataTest.cpp
+++ b/llvm/unittests/TableGen/AutomataTest.cpp
@@ -30,7 +30,7 @@ using testing::UnorderedElementsAre;
 #include "AutomataAutomata.inc"
 
 TEST(Automata, SimpleAutomatonAcceptsFromInitialState) {
-  Automaton<SymKind> A(makeArrayRef(SimpleAutomatonTransitions));
+  Automaton<SymKind> A{ArrayRef(SimpleAutomatonTransitions)};
   EXPECT_TRUE(A.add(SK_a));
   A.reset();
   EXPECT_TRUE(A.add(SK_b));
@@ -41,7 +41,7 @@ TEST(Automata, SimpleAutomatonAcceptsFromInitialState) {
 }
 
 TEST(Automata, SimpleAutomatonAcceptsSequences) {
-  Automaton<SymKind> A(makeArrayRef(SimpleAutomatonTransitions));
+  Automaton<SymKind> A{ArrayRef(SimpleAutomatonTransitions)};
   // Test sequence <a b>
   A.reset();
   EXPECT_TRUE(A.add(SK_a));
@@ -59,7 +59,7 @@ TEST(Automata, SimpleAutomatonAcceptsSequences) {
 }
 
 TEST(Automata, TupleAutomatonAccepts) {
-  Automaton<TupleAutomatonAction> A(makeArrayRef(TupleAutomatonTransitions));
+  Automaton<TupleAutomatonAction> A{ArrayRef(TupleAutomatonTransitions)};
   A.reset();
   EXPECT_TRUE(
       A.add(TupleAutomatonAction{SK_a, SK_b, "yeet"}));
@@ -75,7 +75,7 @@ TEST(Automata, TupleAutomatonAccepts) {
 }
 
 TEST(Automata, NfaAutomatonAccepts) {
-  Automaton<SymKind> A(makeArrayRef(NfaAutomatonTransitions));
+  Automaton<SymKind> A{ArrayRef(NfaAutomatonTransitions)};
 
   // Test sequences <a a>, <a b>, <b a>, <b b>. All should be accepted.
   A.reset();
@@ -99,7 +99,8 @@ TEST(Automata, NfaAutomatonAccepts) {
 }
 
 TEST(Automata, BinPackerAutomatonAccepts) {
-  Automaton<BinPackerAutomatonAction> A(makeArrayRef(BinPackerAutomatonTransitions));
+  Automaton<BinPackerAutomatonAction> A{
+      ArrayRef(BinPackerAutomatonTransitions)};
 
   // Expect that we can pack two double-bins in 0-4, then no more in 0-4.
   A.reset();
@@ -129,8 +130,9 @@ TEST(Automata, BinPackerAutomatonAccepts) {
   ((a << 5) | (b << 4) | (c << 3) | (d << 2) | (e << 1) | (f << 0))
 
 TEST(Automata, BinPackerAutomatonExplains) {
-  Automaton<BinPackerAutomatonAction> A(makeArrayRef(BinPackerAutomatonTransitions),
-                                        makeArrayRef(BinPackerAutomatonTransitionInfo));
+  Automaton<BinPackerAutomatonAction> A{
+      ArrayRef(BinPackerAutomatonTransitions),
+      ArrayRef(BinPackerAutomatonTransitionInfo)};
   // Pack two double-bins in 0-4, then a single bin in 0-6.
   EXPECT_TRUE(A.add(BRK_0_to_4_dbl));
   EXPECT_TRUE(A.add(BRK_0_to_4_dbl));
diff --git a/llvm/unittests/Target/AArch64/AArch64InstPrinterTest.cpp b/llvm/unittests/Target/AArch64/AArch64InstPrinterTest.cpp
index 9605d93..52e04db 100644
--- a/llvm/unittests/Target/AArch64/AArch64InstPrinterTest.cpp
+++ b/llvm/unittests/Target/AArch64/AArch64InstPrinterTest.cpp
@@ -37,9 +37,9 @@ static std::string AArch64InstPrinterTestPrintAlignedLabel(uint64_t value) {
   MCInstrInfo MII;
   MCRegisterInfo MRI;
   MCSubtargetInfo STI(Triple(""), "", "", "",
-                      makeArrayRef((SubtargetFeatureKV *)NULL, 0),
-                      makeArrayRef((SubtargetSubTypeKV *)NULL, 0), NULL, NULL,
-                      NULL, NULL, NULL, NULL);
+                      ArrayRef((SubtargetFeatureKV *)NULL, (size_t)0),
+                      ArrayRef((SubtargetSubTypeKV *)NULL, (size_t)0), NULL,
+                      NULL, NULL, NULL, NULL, NULL);
   MCContext Ctx(Triple(""), &MAI, &MRI, &STI);
   MCInst MI;