[ADT] Have ArrayRef::copy() return a MutableArrayRef

[int3]

Summary

The allocated memory itself is mutable, so let's expose that to the
caller. LLD has a use case for this.

[MaskRay]

Looks great! lld/MachO/ICF.cpp doesn't use std::uninitialized_copy yet. You will need to remove the change to lld/MachO.

llvm/include/llvm/ADT/ArrayRef.h

 #include <cstddef>
 #include <initializer_list>
 #include <iterator>
 #include <memory>
 #include <type_traits>
 #include <vector>
 
 namespace llvm {
+  template<typename T> class LLVM_NODISCARD MutableArrayRef;
 
   /// ArrayRef - Represent a constant reference to an array (0 or more elements
   /// consecutively in memory), i.e. a start pointer and a length.  It allows
   /// various APIs to take consecutive elements easily and conveniently.
   ///
   /// This class does not own the underlying data, it is expected to be used in
   /// situations where the data resides in some other buffer, whose lifetime
   /// extends past that of the ArrayRef. For this reason, it is not in general
#endif
 
     /// back - Get the last element.
     const T &back() const {
       assert(!empty());
       return Data[Length-1];
     }
 
     // copy - Allocate copy in Allocator and return ArrayRef<T> to it.
-    template <typename Allocator> ArrayRef<T> copy(Allocator &A) {
+    template <typename Allocator> MutableArrayRef<T> copy(Allocator &A) {
       T *Buff = A.template Allocate<T>(Length);
       std::uninitialized_copy(begin(), end(), Buff);
-      return ArrayRef<T>(Buff, Length);
+      return MutableArrayRef<T>(Buff, Length);
     }
 
     /// equals - Check for element-wise equality.
     bool equals(ArrayRef RHS) const {
       if (Length != RHS.Length)
         return false;
       return std::equal(begin(), end(), RHS.begin());
     }