[llvm][ADT] Replace uses of `makeMutableArrayRef` with deduction guides

[jloser]

Summary

Similar to how makeArrayRef is deprecated in favor of deduction guides, do the
same for makeMutableArrayRef.

Once all of the places in-tree are using the deduction guides for
MutableArrayRef, we can mark makeMutableArrayRef as deprecated.

[serge-sans-paille]

LGTM

lldb/source/Host/common/NativeProcessProtocol.cpp

651–652

random nit: This could be rewritten as

llvm::MutableArrayRef data(static_cast<uint8_t *>(buf), bytes_read);

now

[jloser]

lldb/source/Host/common/NativeProcessProtocol.cpp

651–652

Yep, I just changed that before landing this. Thanks for the review!

bolt/lib/Profile/DataAggregator.cpp

if (!FD) {
     consumeError(FD.takeError());
     return false;
   }
 
   char Buf[7] = {0, 0, 0, 0, 0, 0, 0};
 
   auto Close = make_scope_exit([&] { sys::fs::closeFile(*FD); });
   Expected<size_t> BytesRead = sys::fs::readNativeFileSlice(
-      *FD, makeMutableArrayRef(Buf, sizeof(Buf)), 0);
+      *FD, MutableArrayRef(Buf, sizeof(Buf)), 0);
   if (!BytesRead) {
     consumeError(BytesRead.takeError());
     return false;
   }
 
   if (*BytesRead != 7)
     return false;
 

clang-tools-extra/clangd/FuzzyMatch.cpp

for (int I = 0; I < PatN; ++I)
     LowPat[I] = lower(Pat[I]);
   Scores[0][0][Miss] = {0, Miss};
   Scores[0][0][Match] = {AwfulScore, Miss};
   for (int P = 0; P <= PatN; ++P)
     for (int W = 0; W < P; ++W)
       for (Action A : {Miss, Match})
         Scores[P][W][A] = {AwfulScore, Miss};
   PatTypeSet = calculateRoles(llvm::StringRef(Pat, PatN),
-                              llvm::makeMutableArrayRef(PatRole, PatN));
+                              llvm::MutableArrayRef(PatRole, PatN));
 }
 
 std::optional<float> FuzzyMatcher::match(llvm::StringRef Word) {
   if (!(WordContainsPattern = init(Word)))
     return std::nullopt;
   if (!PatN)
     return 1;
   buildGraph();
for (int W = 0, P = 0; P != PatN; ++W) {
     if (LowWord[W] == LowPat[P])
       ++P;
   }
 
   // FIXME: some words are hard to tokenize algorithmically.
   // e.g. vsprintf is V S Print F, and should match [pri] but not [int].
   // We could add a tokenization dictionary for common stdlib names.
   WordTypeSet = calculateRoles(llvm::StringRef(Word, WordN),
-                               llvm::makeMutableArrayRef(WordRole, WordN));
+                               llvm::MutableArrayRef(WordRole, WordN));
   return true;
 }
 
 // The forwards pass finds the mappings of Pattern onto Word.
 // Score = best score achieved matching Word[..W] against Pat[..P].
 // Unlike other tables, indices range from 0 to N *inclusive*
 // Matched = whether we chose to match Word[W] with Pat[P] or not.
 //

clang-tools-extra/clangd/SemanticSelection.cpp

if (Ranges.empty()) {
     return std::move(Empty);
   }
 
   // Convert to the LSP linked-list representation.
   SelectionRange Head;
   Head.range = std::move(Ranges.front());
   SelectionRange *Tail = &Head;
   for (auto &Range :
-       llvm::makeMutableArrayRef(Ranges.data(), Ranges.size()).drop_front()) {
+       llvm::MutableArrayRef(Ranges.data(), Ranges.size()).drop_front()) {
     Tail->parent = std::make_unique<SelectionRange>();
     Tail = Tail->parent.get();
     Tail->range = std::move(Range);
   }
 
   return std::move(Head);
 }
 

clang-tools-extra/clangd/index/dex/Trigram.cpp

 
 // Produce trigrams (including duplicates) and pass them to Out().
 template <typename Func>
 static void identifierTrigrams(llvm::StringRef Identifier, Func Out) {
   assert(!Identifier.empty());
   // Apply fuzzy matching text segmentation.
   llvm::SmallVector<CharRole> Roles(Identifier.size());
   calculateRoles(Identifier,
-                 llvm::makeMutableArrayRef(Roles.data(), Identifier.size()));
+                 llvm::MutableArrayRef(Roles.data(), Identifier.size()));
 
   std::string LowercaseIdentifier = Identifier.lower();
 
   // For each character, store indices of the characters to which fuzzy matching
   // algorithm can jump. There are 2 possible variants:
   //
   // * Next Tail - next character from the same segment
   // * Next Head - front character of the next segment

 }
 
 std::vector<Token> generateQueryTrigrams(llvm::StringRef Query) {
   if (Query.empty())
     return {};
 
   // Apply fuzzy matching text segmentation.
   llvm::SmallVector<CharRole> Roles(Query.size());
-  calculateRoles(Query, llvm::makeMutableArrayRef(Roles.data(), Query.size()));
+  calculateRoles(Query, llvm::MutableArrayRef(Roles.data(), Query.size()));
 
   std::string LowercaseQuery = Query.lower();
 
   llvm::DenseSet<Token> UniqueTrigrams;
   std::string Chars;
   for (unsigned I = 0; I < LowercaseQuery.size(); ++I) {
     if (Roles[I] != Head && Roles[I] != Tail)
       continue; // Skip delimiters.

clang-tools-extra/pseudo/include/clang-pseudo/Forest.h

ambiguousData(llvm::ArrayRef<const ForestNode *> Alternatives) {
     return Alternatives.size();
   }
 
   // Retrieves the trailing array.
   llvm::ArrayRef<const ForestNode *> children(uint16_t Num) const {
     return llvm::ArrayRef(reinterpret_cast<ForestNode *const *>(this + 1), Num);
   }
   llvm::MutableArrayRef<ForestNode *> children(uint16_t Num) {
-    return llvm::makeMutableArrayRef(reinterpret_cast<ForestNode **>(this + 1),
-                                     Num);
+    return llvm::MutableArrayRef(reinterpret_cast<ForestNode **>(this + 1),
   }
 
   Token::Index StartIndex;
   Kind K : 4;
   SymbolID Symbol : SymbolBits;
   // Sequence - child count : 4 | RuleID : RuleBits (12)
   // Ambiguous - child count : 16
   // Terminal, Opaque - unused

clang/include/clang/AST/DeclOpenMP.h

class OMPThreadPrivateDecl final : public OMPDeclarativeDirective<Decl> {
 
   ArrayRef<const Expr *> getVars() const {
     auto **Storage = reinterpret_cast<Expr **>(Data->getChildren().data());
     return llvm::ArrayRef(Storage, Data->getNumChildren());
   }
 
   MutableArrayRef<Expr *> getVars() {
     auto **Storage = reinterpret_cast<Expr **>(Data->getChildren().data());
-    return llvm::makeMutableArrayRef(Storage, Data->getNumChildren());
+    return llvm::MutableArrayRef(Storage, Data->getNumChildren());
   }
 
   void setVars(ArrayRef<Expr *> VL);
 
 public:
   static OMPThreadPrivateDecl *Create(ASTContext &C, DeclContext *DC,
                                       SourceLocation L,
                                       ArrayRef<Expr *> VL);
class OMPAllocateDecl final : public OMPDeclarativeDirective<Decl> {
 
   ArrayRef<const Expr *> getVars() const {
     auto **Storage = reinterpret_cast<Expr **>(Data->getChildren().data());
     return llvm::ArrayRef(Storage, Data->getNumChildren());
   }
 
   MutableArrayRef<Expr *> getVars() {
     auto **Storage = reinterpret_cast<Expr **>(Data->getChildren().data());
-    return llvm::makeMutableArrayRef(Storage, Data->getNumChildren());
+    return llvm::MutableArrayRef(Storage, Data->getNumChildren());
   }
 
   void setVars(ArrayRef<Expr *> VL);
 
 public:
   static OMPAllocateDecl *Create(ASTContext &C, DeclContext *DC,
                                  SourceLocation L, ArrayRef<Expr *> VL,
                                  ArrayRef<OMPClause *> CL);

clang/include/clang/AST/OpenMPClause.h

void setMapperIdInfo(DeclarationNameInfo MapperId) {
     MapperIdInfo = MapperId;
   }
 
   /// Get the user-defined mapper references that are in the trailing objects of
   /// the class.
   MutableArrayRef<Expr *> getUDMapperRefs() {
     assert(SupportsMapper &&
            "Must be a clause that is possible to have user-defined mappers");
-    return llvm::makeMutableArrayRef<Expr *>(
+    return llvm::MutableArrayRef<Expr *>(
         static_cast<T *>(this)->template getTrailingObjects<Expr *>() +
             OMPVarListClause<T>::varlist_size(),
         OMPVarListClause<T>::varlist_size());
   }
 
   /// Get the user-defined mappers references that are in the trailing objects
   /// of the class.
   ArrayRef<Expr *> getUDMapperRefs() const {
public:
   Stmt *getAssociatedStmt() {
     assert(HasAssociatedStmt &&
            "Expected directive with the associated statement.");
     return getTrailingObjects<Stmt *>()[NumChildren];
   }
 
   /// Get the clauses storage.
   MutableArrayRef<OMPClause *> getClauses() {
-    return llvm::makeMutableArrayRef(getTrailingObjects<OMPClause *>(),
+    return llvm::MutableArrayRef(getTrailingObjects<OMPClause *>(),
                                      NumClauses);
   }
   ArrayRef<OMPClause *> getClauses() const {
     return const_cast<OMPChildren *>(this)->getClauses();
   }
 
   /// Returns the captured statement associated with the
   /// component region within the (combined) directive.

clang/include/clang/AST/StmtOpenMP.h

enum {
     // arrays) for combined distribute loop directives.
     CombinedDistributeEnd = 29,
   };
 
   /// Get the counters storage.
   MutableArrayRef<Expr *> getCounters() {
     auto **Storage = reinterpret_cast<Expr **>(
         &Data->getChildren()[getArraysOffset(getDirectiveKind())]);
-    return llvm::makeMutableArrayRef(Storage, getLoopsNumber());
+    return llvm::MutableArrayRef(Storage, getLoopsNumber());
   }
 
   /// Get the private counters storage.
   MutableArrayRef<Expr *> getPrivateCounters() {
     auto **Storage = reinterpret_cast<Expr **>(
         &Data->getChildren()[getArraysOffset(getDirectiveKind()) +
                              getLoopsNumber()]);
-    return llvm::makeMutableArrayRef(Storage, getLoopsNumber());
+    return llvm::MutableArrayRef(Storage, getLoopsNumber());
   }
 
   /// Get the updates storage.
   MutableArrayRef<Expr *> getInits() {
     auto **Storage = reinterpret_cast<Expr **>(
         &Data->getChildren()[getArraysOffset(getDirectiveKind()) +
                              2 * getLoopsNumber()]);
-    return llvm::makeMutableArrayRef(Storage, getLoopsNumber());
+    return llvm::MutableArrayRef(Storage, getLoopsNumber());
   }
 
   /// Get the updates storage.
   MutableArrayRef<Expr *> getUpdates() {
     auto **Storage = reinterpret_cast<Expr **>(
         &Data->getChildren()[getArraysOffset(getDirectiveKind()) +
                              3 * getLoopsNumber()]);
-    return llvm::makeMutableArrayRef(Storage, getLoopsNumber());
+    return llvm::MutableArrayRef(Storage, getLoopsNumber());
   }
 
   /// Get the final counter updates storage.
   MutableArrayRef<Expr *> getFinals() {
     auto **Storage = reinterpret_cast<Expr **>(
         &Data->getChildren()[getArraysOffset(getDirectiveKind()) +
                              4 * getLoopsNumber()]);
-    return llvm::makeMutableArrayRef(Storage, getLoopsNumber());
+    return llvm::MutableArrayRef(Storage, getLoopsNumber());
   }
 
   /// Get the dependent counters storage.
   MutableArrayRef<Expr *> getDependentCounters() {
     auto **Storage = reinterpret_cast<Expr **>(
         &Data->getChildren()[getArraysOffset(getDirectiveKind()) +
                              5 * getLoopsNumber()]);
-    return llvm::makeMutableArrayRef(Storage, getLoopsNumber());
+    return llvm::MutableArrayRef(Storage, getLoopsNumber());
   }
 
   /// Get the dependent inits storage.
   MutableArrayRef<Expr *> getDependentInits() {
     auto **Storage = reinterpret_cast<Expr **>(
         &Data->getChildren()[getArraysOffset(getDirectiveKind()) +
                              6 * getLoopsNumber()]);
-    return llvm::makeMutableArrayRef(Storage, getLoopsNumber());
+    return llvm::MutableArrayRef(Storage, getLoopsNumber());
   }
 
   /// Get the finals conditions storage.
   MutableArrayRef<Expr *> getFinalsConditions() {
     auto **Storage = reinterpret_cast<Expr **>(
         &Data->getChildren()[getArraysOffset(getDirectiveKind()) +
                              7 * getLoopsNumber()]);
-    return llvm::makeMutableArrayRef(Storage, getLoopsNumber());
+    return llvm::MutableArrayRef(Storage, getLoopsNumber());
   }
 
 protected:
   /// Build instance of loop directive of class \a Kind.
   ///
   /// \param SC Statement class.
   /// \param Kind Kind of OpenMP directive.
   /// \param StartLoc Starting location of the directive (directive keyword).

clang/include/clang/Lex/MacroInfo.h

public:
 
   llvm::MutableArrayRef<Token>
   allocateTokens(unsigned NumTokens, llvm::BumpPtrAllocator &PPAllocator) {
     assert(ReplacementTokens == nullptr && NumReplacementTokens == 0 &&
            "Token list already allocated!");
     NumReplacementTokens = NumTokens;
     Token *NewReplacementTokens = PPAllocator.Allocate<Token>(NumTokens);
     ReplacementTokens = NewReplacementTokens;
-    return llvm::makeMutableArrayRef(NewReplacementTokens, NumTokens);
+    return llvm::MutableArrayRef(NewReplacementTokens, NumTokens);
   }
 
   void setTokens(ArrayRef<Token> Tokens, llvm::BumpPtrAllocator &PPAllocator) {
     assert(
         !IsDefinitionLengthCached &&
         "Changing replacement tokens after definition length got calculated");
     assert(ReplacementTokens == nullptr && NumReplacementTokens == 0 &&
            "Token list already set!");

clang/lib/AST/StmtOpenMP.cpp

 
 void OMPChildren::setClauses(ArrayRef<OMPClause *> Clauses) {
   assert(Clauses.size() == NumClauses &&
          "Number of clauses is not the same as the preallocated buffer");
   llvm::copy(Clauses, getTrailingObjects<OMPClause *>());
 }
 
 MutableArrayRef<Stmt *> OMPChildren::getChildren() {
-  return llvm::makeMutableArrayRef(getTrailingObjects<Stmt *>(), NumChildren);
+  return llvm::MutableArrayRef(getTrailingObjects<Stmt *>(), NumChildren);
 }
 
 OMPChildren *OMPChildren::Create(void *Mem, ArrayRef<OMPClause *> Clauses) {
   auto *Data = CreateEmpty(Mem, Clauses.size());
   Data->setClauses(Clauses);
   return Data;
 }
 

lld/COFF/Chunks.cpp

 }
 
 void RVAFlagTableChunk::writeTo(uint8_t *buf) const {
   struct RVAFlag {
     ulittle32_t rva;
     uint8_t flag;
   };
   auto flags =
-      makeMutableArrayRef(reinterpret_cast<RVAFlag *>(buf), syms.size());
+      MutableArrayRef(reinterpret_cast<RVAFlag *>(buf), syms.size());
   for (auto t : zip(syms, flags)) {
     const auto &sym = std::get<0>(t);
     auto &flag = std::get<1>(t);
     flag.rva = sym.inputChunk->getRVA() + sym.offset;
     flag.flag = 0;
   }
   llvm::sort(flags,
              [](const RVAFlag &a, const RVAFlag &b) { return a.rva < b.rva; });

lld/COFF/DebugTypes.cpp

void TpiSource::mergeTypeRecord(TypeIndex curIndex, CVType ty) {
   bool isItem = isIdRecord(ty.kind());
   MergedInfo &merged = isItem ? mergedIpi : mergedTpi;
 
   // Copy the type into our mutable buffer.
   assert(ty.length() <= codeview::MaxRecordLength);
   size_t offset = merged.recs.size();
   size_t newSize = alignTo(ty.length(), 4);
   merged.recs.resize(offset + newSize);
-  auto newRec = makeMutableArrayRef(&merged.recs[offset], newSize);
+  auto newRec = MutableArrayRef(&merged.recs[offset], newSize);
   memcpy(newRec.data(), ty.data().data(), newSize);
 
   // Fix up the record prefix and padding bytes if it required resizing.
   if (newSize != ty.length()) {
     reinterpret_cast<RecordPrefix *>(newRec.data())->RecordLen = newSize - 2;
     for (size_t i = ty.length(); i < newSize; ++i)
       newRec[i] = LF_PAD0 + (newSize - i);
   }

lld/COFF/Writer.cpp

for (size_t i = 0; i != os->chunks.size(); ++i) {
 
     // Get a writable copy of this section's relocations so they can be
     // modified. If the relocations point into the object file, allocate new
     // memory. Otherwise, this must be previously allocated memory that can be
     // modified in place.
     ArrayRef<coff_relocation> curRelocs = sc->getRelocs();
     MutableArrayRef<coff_relocation> newRelocs;
     if (originalRelocs.data() == curRelocs.data()) {
-      newRelocs = makeMutableArrayRef(
+      newRelocs = MutableArrayRef(
           bAlloc().Allocate<coff_relocation>(originalRelocs.size()),
           originalRelocs.size());
     } else {
-      newRelocs = makeMutableArrayRef(
+      newRelocs = MutableArrayRef(
           const_cast<coff_relocation *>(curRelocs.data()), curRelocs.size());
     }
 
     // Copy each relocation, but replace the symbol table indices which need
     // thunks.
     auto nextReplacement = relocReplacements.begin();
     auto endReplacement = relocReplacements.end();
     for (size_t i = 0, e = originalRelocs.size(); i != e; ++i) {

lld/ELF/InputFiles.h

if (numSymbols == 0)
       return {};
     return llvm::ArrayRef(symbols.get() + 1, firstGlobal - 1);
   }
   ArrayRef<Symbol *> getGlobalSymbols() {
     return llvm::ArrayRef(symbols.get() + firstGlobal,
                           numSymbols - firstGlobal);
   }
   MutableArrayRef<Symbol *> getMutableGlobalSymbols() {
-    return llvm::makeMutableArrayRef(symbols.get() + firstGlobal,
+    return llvm::MutableArrayRef(symbols.get() + firstGlobal,
                                      numSymbols - firstGlobal);
   }
 
   template <typename ELFT> typename ELFT::ShdrRange getELFShdrs() const {
     return typename ELFT::ShdrRange(
         reinterpret_cast<const typename ELFT::Shdr *>(elfShdrs), numELFShdrs);
   }
   template <typename ELFT> typename ELFT::SymRange getELFSyms() const {

lld/ELF/SyntheticSections.cpp

createSymbols(
   for (ArrayRef<GdbSymbol> v : ArrayRef(symbols.get(), numShards))
     numSymbols += v.size();
 
   // The return type is a flattened vector, so we'll copy each vector
   // contents to Ret.
   SmallVector<GdbSymbol, 0> ret;
   ret.reserve(numSymbols);
   for (SmallVector<GdbSymbol, 0> &vec :
-       makeMutableArrayRef(symbols.get(), numShards))
+       MutableArrayRef(symbols.get(), numShards))
     for (GdbSymbol &sym : vec)
       ret.push_back(std::move(sym));
 
   // CU vectors and symbol names are adjacent in the output file.
   // We can compute their offsets in the output file now.
   size_t off = 0;
   for (GdbSymbol &sym : ret) {
     sym.cuVectorOff = off;

lldb/source/Host/common/NativeProcessProtocol.cpp

 }
 
 Status NativeProcessProtocol::ReadMemoryWithoutTrap(lldb::addr_t addr,
                                                     void *buf, size_t size,
                                                     size_t &bytes_read) {
   Status error = ReadMemory(addr, buf, size, bytes_read);
   if (error.Fail())
     return error;
 
-  auto data =
-      llvm::makeMutableArrayRef(static_cast<uint8_t *>(buf), bytes_read);
+  llvm::MutableArrayRef data(static_cast<uint8_t *>(buf), bytes_read);
   for (const auto &pair : m_software_breakpoints) {
     lldb::addr_t bp_addr = pair.first;
     auto saved_opcodes = llvm::ArrayRef(pair.second.saved_opcodes);
 
     if (bp_addr + saved_opcodes.size() < addr || addr + bytes_read <= bp_addr)
       continue; // Breakpoint not in range, ignore
 
     if (bp_addr < addr) {

llvm/include/llvm/DebugInfo/DWARF/DWARFUnitIndex.h

ArrayRef<DWARFSectionKind> getColumnKinds() const {
     return ArrayRef(ColumnKinds.get(), Header.NumColumns);
   }
 
   ArrayRef<Entry> getRows() const {
     return ArrayRef(Rows.get(), Header.NumBuckets);
   }
 
   MutableArrayRef<Entry> getMutableRows() {
-    return makeMutableArrayRef(Rows.get(), Header.NumBuckets);
+    return MutableArrayRef(Rows.get(), Header.NumBuckets);
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFUNITINDEX_H

llvm/include/llvm/IR/DataLayout.h

public:
   /// NB: Padding in nested element is not taken into account.
   bool hasPadding() const { return IsPadded; }
 
   /// Given a valid byte offset into the structure, returns the structure
   /// index that contains it.
   unsigned getElementContainingOffset(uint64_t Offset) const;
 
   MutableArrayRef<uint64_t> getMemberOffsets() {
-    return llvm::makeMutableArrayRef(getTrailingObjects<uint64_t>(),
+    return llvm::MutableArrayRef(getTrailingObjects<uint64_t>(),
                                      NumElements);
   }
 
   ArrayRef<uint64_t> getMemberOffsets() const {
     return llvm::ArrayRef(getTrailingObjects<uint64_t>(), NumElements);
   }
 
   uint64_t getElementOffset(unsigned Idx) const {

llvm/include/llvm/IR/Metadata.h

struct alignas(alignof(size_t)) Header {
     void resize(size_t NumOps);
 
     explicit Header(size_t NumOps, StorageType Storage);
     ~Header();
 
     MutableArrayRef<MDOperand> operands() {
       if (IsLarge)
         return getLarge();
-      return makeMutableArrayRef(
+      return MutableArrayRef(
           reinterpret_cast<MDOperand *>(this) - SmallSize, SmallNumOps);
     }
 
     ArrayRef<MDOperand> operands() const {
       if (IsLarge)
         return getLarge();
       return ArrayRef(reinterpret_cast<const MDOperand *>(this) - SmallSize,
                       SmallNumOps);

llvm/include/llvm/ProfileData/InstrProf.h

private:
 
   MutableArrayRef<InstrProfValueSiteRecord>
   getValueSitesForKind(uint32_t ValueKind) {
     // Cast to /add/ const (should be an implicit_cast, ideally, if that's ever
     // implemented in LLVM) to call the const overload of this function, then
     // cast away the constness from the result.
     auto AR = const_cast<const InstrProfRecord *>(this)->getValueSitesForKind(
         ValueKind);
-    return makeMutableArrayRef(
+    return MutableArrayRef(
         const_cast<InstrProfValueSiteRecord *>(AR.data()), AR.size());
   }
   ArrayRef<InstrProfValueSiteRecord>
   getValueSitesForKind(uint32_t ValueKind) const {
     if (!ValueData)
       return std::nullopt;
     switch (ValueKind) {
     case IPVK_IndirectCallTarget:

llvm/include/llvm/Support/Parallel.h

std::vector<ResultTy> Results(NumTasks, Init);
     assert(TBegin == End);
   }
 
   // Do a final reduction. There are at most 1024 tasks, so this only adds
   // constant single-threaded overhead for large inputs. Hopefully most
   // reductions are cheaper than the transformation.
   ResultTy FinalResult = std::move(Results.front());
   for (ResultTy &PartialResult :
-       makeMutableArrayRef(Results.data() + 1, Results.size() - 1))
+       MutableArrayRef(Results.data() + 1, Results.size() - 1))
     FinalResult = Reduce(FinalResult, std::move(PartialResult));
   return std::move(FinalResult);
 }
 
 #endif
 
 } // namespace detail
 } // namespace parallel

llvm/lib/Analysis/ConstantFolding.cpp

Constant *ConstantFoldSSEConvertToInt(const APFloat &Val, bool roundTowardZero,
   assert(ResultWidth <= 64 &&
          "Can only constant fold conversions to 64 and 32 bit ints");
 
   uint64_t UIntVal;
   bool isExact = false;
   APFloat::roundingMode mode = roundTowardZero? APFloat::rmTowardZero
                                               : APFloat::rmNearestTiesToEven;
   APFloat::opStatus status =
-      Val.convertToInteger(makeMutableArrayRef(UIntVal), ResultWidth,
+      Val.convertToInteger(MutableArrayRef(UIntVal), ResultWidth,
                            IsSigned, mode, &isExact);
   if (status != APFloat::opOK &&
       (!roundTowardZero || status != APFloat::opInexact))
     return nullptr;
   return ConstantInt::get(Ty, UIntVal, IsSigned);
 }
 
 double getValueAsDouble(ConstantFP *Op) {

llvm/lib/ExecutionEngine/ExecutionEngine.cpp

case Instruction::FPToSI: {
       if (Op0->getType()->isFloatTy())
         GV.IntVal = APIntOps::RoundFloatToAPInt(GV.FloatVal, BitWidth);
       else if (Op0->getType()->isDoubleTy())
         GV.IntVal = APIntOps::RoundDoubleToAPInt(GV.DoubleVal, BitWidth);
       else if (Op0->getType()->isX86_FP80Ty()) {
         APFloat apf = APFloat(APFloat::x87DoubleExtended(), GV.IntVal);
         uint64_t v;
         bool ignored;
-        (void)apf.convertToInteger(makeMutableArrayRef(v), BitWidth,
+        (void)apf.convertToInteger(MutableArrayRef(v), BitWidth,
                                    CE->getOpcode()==Instruction::FPToSI,
                                    APFloat::rmTowardZero, &ignored);
         GV.IntVal = v; // endian?
       }
       return GV;
     }
     case Instruction::PtrToInt: {
       GenericValue GV = getConstantValue(Op0);

llvm/lib/Support/Path.cpp

Error readNativeFileToEOF(file_t FileHandle, SmallVectorImpl<char> &Buffer,
   // Install a handler to truncate the buffer to the correct size on exit.
   size_t Size = Buffer.size();
   auto TruncateOnExit = make_scope_exit([&]() { Buffer.truncate(Size); });
 
   // Read into Buffer until we hit EOF.
   for (;;) {
     Buffer.resize_for_overwrite(Size + ChunkSize);
     Expected<size_t> ReadBytes = readNativeFile(
-        FileHandle, makeMutableArrayRef(Buffer.begin() + Size, ChunkSize));
+        FileHandle, MutableArrayRef(Buffer.begin() + Size, ChunkSize));
     if (!ReadBytes)
       return ReadBytes.takeError();
     if (*ReadBytes == 0)
       return Error::success();
     Size += *ReadBytes;
   }
 }
 

llvm/lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp

for (unsigned i = 0; i <= Accum.size() / 2; ++i) {
     // Partial products at offset 2 * i - 1.
     if (i > 0) {
       if (!SeparateOddAlignedProducts) {
         auto LocalAccum = Accum.drop_front(2 * i - 1).take_front(2);
         OddCarry = buildMadChain(LocalAccum, 2 * i - 1, OddCarryIn);
       } else {
         bool IsHighest = 2 * i >= Accum.size();
         Register SeparateOddOut[2];
-        auto LocalAccum = makeMutableArrayRef(SeparateOddOut)
+        auto LocalAccum = MutableArrayRef(SeparateOddOut)
                               .take_front(IsHighest ? 1 : 2);
         OddCarry = buildMadChain(LocalAccum, 2 * i - 1, OddCarryIn);
 
         MachineInstr *Lo;
 
         if (i == 1) {
           if (!IsHighest)
             Lo = B.buildUAddo(S32, S1, Accum[2 * i - 1], SeparateOddOut[0]);

llvm/lib/Transforms/Scalar/IndVarSimplify.cpp

 // rewriteNonIntegerIVs and helpers. Prefer integer IVs.
 //===----------------------------------------------------------------------===//
 
 /// Convert APF to an integer, if possible.
 static bool ConvertToSInt(const APFloat &APF, int64_t &IntVal) {
   bool isExact = false;
   // See if we can convert this to an int64_t
   uint64_t UIntVal;
-  if (APF.convertToInteger(makeMutableArrayRef(UIntVal), 64, true,
+  if (APF.convertToInteger(MutableArrayRef(UIntVal), 64, true,
                            APFloat::rmTowardZero, &isExact) != APFloat::opOK ||
       !isExact)
     return false;
   IntVal = UIntVal;
   return true;
 }
 
 /// If the loop has floating induction variable then insert corresponding

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

auto &&EstimateShufflesCost = [this, FTy,
                              "insertelement users.\n";
                    if (TEs.front()) { TEs.front()->dump(); } TEs.back()->dump();
                    dbgs() << "SLP: Current total cost = " << Cost << "\n");
         Cost += C;
       }
       return TEs.back();
     };
     (void)performExtractsShuffleAction<const TreeEntry>(
-        makeMutableArrayRef(Vector.data(), Vector.size()), Base,
+        MutableArrayRef(Vector.data(), Vector.size()), Base,
         [](const TreeEntry *E) { return E->getVectorFactor(); }, ResizeToVF,
         EstimateShufflesCost);
     InstructionCost InsertCost = TTI->getScalarizationOverhead(
         cast<FixedVectorType>(FirstUsers[I].first->getType()), DemandedElts[I],
         /*Insert*/ true, /*Extract*/ false);
     Cost -= InsertCost;
   }
 
Value *BoUpSLP::vectorizeTree(ExtraValueToDebugLocsMap &ExternallyUsedValues,
   for (int I = 0, E = ShuffledInserts.size(); I < E; ++I) {
     // Find the first and the last instruction in the list of insertelements.
     sort(ShuffledInserts[I].InsertElements, isFirstInsertElement);
     InsertElementInst *FirstInsert = ShuffledInserts[I].InsertElements.front();
     InsertElementInst *LastInsert = ShuffledInserts[I].InsertElements.back();
     Builder.SetInsertPoint(LastInsert);
     auto Vector = ShuffledInserts[I].ValueMasks.takeVector();
     Value *NewInst = performExtractsShuffleAction<Value>(
-        makeMutableArrayRef(Vector.data(), Vector.size()),
+        MutableArrayRef(Vector.data(), Vector.size()),
         FirstInsert->getOperand(0),
         [](Value *Vec) {
           return cast<VectorType>(Vec->getType())
               ->getElementCount()
               .getKnownMinValue();
         },
         ResizeToVF,
         [FirstInsert, &CreateShuffle](ArrayRef<int> Mask,

llvm/unittests/Support/Path.cpp

TEST_F(FileSystemTest, readNativeFile) {
   FileRemover Cleanup(NonExistantFile);
   const auto &Read = [&](size_t ToRead) -> Expected<std::string> {
     std::string Buf(ToRead, '?');
     Expected<fs::file_t> FD = fs::openNativeFileForRead(NonExistantFile);
     if (!FD)
       return FD.takeError();
     auto Close = make_scope_exit([&] { fs::closeFile(*FD); });
     if (Expected<size_t> BytesRead = fs::readNativeFile(
-            *FD, makeMutableArrayRef(&*Buf.begin(), Buf.size())))
+            *FD, MutableArrayRef(&*Buf.begin(), Buf.size())))
       return Buf.substr(0, *BytesRead);
     else
       return BytesRead.takeError();
   };
   EXPECT_THAT_EXPECTED(Read(5), HasValue("01234"));
   EXPECT_THAT_EXPECTED(Read(3), HasValue("012"));
   EXPECT_THAT_EXPECTED(Read(6), HasValue("01234"));
 }
TEST_F(FileSystemTest, readNativeFileSlice) {
   FileRemover Cleanup(NonExistantFile);
   Expected<fs::file_t> FD = fs::openNativeFileForRead(NonExistantFile);
   ASSERT_THAT_EXPECTED(FD, Succeeded());
   auto Close = make_scope_exit([&] { fs::closeFile(*FD); });
   const auto &Read = [&](size_t Offset,
                          size_t ToRead) -> Expected<std::string> {
     std::string Buf(ToRead, '?');
     if (Expected<size_t> BytesRead = fs::readNativeFileSlice(
-            *FD, makeMutableArrayRef(&*Buf.begin(), Buf.size()), Offset))
+            *FD, MutableArrayRef(&*Buf.begin(), Buf.size()), Offset))
       return Buf.substr(0, *BytesRead);
     else
       return BytesRead.takeError();
   };
   EXPECT_THAT_EXPECTED(Read(0, 5), HasValue("01234"));
   EXPECT_THAT_EXPECTED(Read(0, 3), HasValue("012"));
   EXPECT_THAT_EXPECTED(Read(2, 3), HasValue("234"));
   EXPECT_THAT_EXPECTED(Read(0, 6), HasValue("01234"));

mlir/lib/Bytecode/Writer/IRNumbering.cpp

IRNumberingState::IRNumberingState(Operation *op) {
   llvm::stable_sort(orderedOpNames, sortByRefCountFn);
   llvm::stable_sort(orderedTypes, sortByRefCountFn);
 
   // After that, we apply a secondary ordering based on the parent dialect. This
   // ordering is applied to sub-sections of the element list defined by how many
   // bytes it takes to encode a varint index to that sub-section. This allows
   // for more efficiently encoding components of the same dialect (e.g. we only
   // have to encode the dialect reference once).
-  groupByDialectPerByte(llvm::makeMutableArrayRef(orderedAttrs));
-  groupByDialectPerByte(llvm::makeMutableArrayRef(orderedOpNames));
-  groupByDialectPerByte(llvm::makeMutableArrayRef(orderedTypes));
+  groupByDialectPerByte(llvm::MutableArrayRef(orderedAttrs));
+  groupByDialectPerByte(llvm::MutableArrayRef(orderedOpNames));
+  groupByDialectPerByte(llvm::MutableArrayRef(orderedTypes));
 
   // Finalize the numbering of the dialect resources.
   finalizeDialectResourceNumberings(op);
 }
 
 void IRNumberingState::number(Attribute attr) {
   auto it = attrs.insert({attr, nullptr});
   if (!it.second) {

mlir/lib/Dialect/Affine/Transforms/LoopCoalescing.cpp

for (unsigned end = loops.size(); end > 0; --end) {
         if (maxPos > start)
           continue;
 
         assert(maxPos == start &&
                "expected loop bounds to be known at the start of the band");
         LLVM_DEBUG(llvm::dbgs() << "  found coalesceable band from " << start
                                 << " to " << end << '\n');
 
-        auto band =
-            llvm::makeMutableArrayRef(loops.data() + start, end - start);
+        auto band = llvm::MutableArrayRef(loops.data() + start, end - start);
         (void)coalesceLoops(band);
         break;
       }
       // If a band was found and transformed, keep looking at the loops above
       // the outermost transformed loop.
       if (start != end - 1)
         end = start + 1;
     }

mlir/test/mlir-tblgen/constraint-unique.td

 // CHECK:         auto [[$A_VALUE_GROUP:.*]] = getODSOperands(0);
 // CHECK:         for (auto [[$A_VALUE:.*]] : [[$A_VALUE_GROUP]])
 // CHECK-NEXT:      if (::mlir::failed([[$A_TYPE_CONSTRAINT]](*this, [[$A_VALUE]].getType(), "operand", index++)))
 // CHECK-NEXT:        return ::mlir::failure();
 // CHECK:         auto [[$RET_VALUE_GROUP:.*]] = getODSResults(0);
 // CHECK:         for (auto [[$RET_VALUE:.*]] : [[$RET_VALUE_GROUP]])
 // CHECK-NEXT:      if (::mlir::failed([[$A_TYPE_CONSTRAINT]](*this, [[$RET_VALUE]].getType(), "result", index++)))
 // CHECK-NEXT:        return ::mlir::failure();
-// CHECK:         for (auto &region : ::llvm::makeMutableArrayRef((*this)->getRegion(0)))
+// CHECK:         for (auto &region : ::llvm::MutableArrayRef((*this)->getRegion(0)))
 // CHECK-NEXT:      if (::mlir::failed([[$A_REGION_CONSTRAINT]](*this, region, "d", index++)))
 // CHECK-NEXT:        return ::mlir::failure();
-// CHECK:         for (auto *successor : ::llvm::makeMutableArrayRef(c()))
+// CHECK:         for (auto *successor : ::llvm::MutableArrayRef(c()))
 // CHECK-NEXT:      if (::mlir::failed([[$A_SUCCESSOR_CONSTRAINT]](*this, successor, "c", index++)))
 // CHECK-NEXT:        return ::mlir::failure();
 
 /// Test that the op with the same predicates but different with descriptions
 /// uses the different constraints.
 // CHECK-LABEL: OpC::verify
 // CHECK:         ::mlir::Attribute [[$B_ATTR:.*b]];
 // CHECK:         if (::mlir::failed([[$O_ATTR_CONSTRAINT]](*this, [[$B_ATTR]], "b")))
 // CHECK-NEXT:      return ::mlir::failure();
 // CHECK:         auto [[$A_VALUE_GROUP:.*]] = getODSOperands(0);
 // CHECK:         for (auto [[$A_VALUE:.*]] : [[$A_VALUE_GROUP]])
 // CHECK-NEXT:      if (::mlir::failed([[$O_TYPE_CONSTRAINT]](*this, [[$A_VALUE]].getType(), "operand", index++)))
 // CHECK-NEXT:        return ::mlir::failure();
 // CHECK:         auto [[$RET_VALUE_GROUP:.*]] = getODSResults(0);
 // CHECK:         for (auto [[$RET_VALUE:.*]] : [[$RET_VALUE_GROUP]])
 // CHECK-NEXT:      if (::mlir::failed([[$O_TYPE_CONSTRAINT]](*this, [[$RET_VALUE]].getType(), "result", index++)))
 // CHECK-NEXT:        return ::mlir::failure();
-// CHECK:         for (auto &region : ::llvm::makeMutableArrayRef((*this)->getRegion(0)))
+// CHECK:         for (auto &region : ::llvm::MutableArrayRef((*this)->getRegion(0)))
 // CHECK-NEXT:      if (::mlir::failed([[$O_REGION_CONSTRAINT]](*this, region, "d", index++)))
 // CHECK-NEXT:        return ::mlir::failure();
-// CHECK:         for (auto *successor : ::llvm::makeMutableArrayRef(c()))
+// CHECK:         for (auto *successor : ::llvm::MutableArrayRef(c()))
 // CHECK-NEXT:      if (::mlir::failed([[$O_SUCCESSOR_CONSTRAINT]](*this, successor, "c", index++)))
 // CHECK-NEXT:        return ::mlir::failure();

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

const char *const verifyRegion = R"(
     for (auto &region : {0})
       if (::mlir::failed({1}(*this, region, "{2}", index++)))
         return ::mlir::failure();
 )";
   /// Get a single region.
   ///
   /// {0}: The region's index.
   const char *const getSingleRegion =
-      "::llvm::makeMutableArrayRef((*this)->getRegion({0}))";
+      "::llvm::MutableArrayRef((*this)->getRegion({0}))";
 
   // If we have no regions, there is nothing more to do.
   const auto canSkip = [](const NamedRegion &region) {
     return region.constraint.getPredicate().isNull();
   };
   auto regions = op.getRegions();
   if (regions.empty() && llvm::all_of(regions, canSkip))
     return;
void OpEmitter::genSuccessorVerifier(MethodBody &body) {
   const char *const verifySuccessor = R"(
     for (auto *successor : {0})
       if (::mlir::failed({1}(*this, successor, "{2}", index++)))
         return ::mlir::failure();
 )";
   /// Get a single successor.
   ///
   /// {0}: The successor's name.
-  const char *const getSingleSuccessor = "::llvm::makeMutableArrayRef({0}())";
+  const char *const getSingleSuccessor = "::llvm::MutableArrayRef({0}())";
 
   // If we have no successors, there is nothing more to do.
   const auto canSkip = [](const NamedSuccessor &successor) {
     return successor.constraint.getPredicate().isNull();
   };
   auto successors = op.getSuccessors();
   if (successors.empty() && llvm::all_of(successors, canSkip))
     return;