[llvm] Explicitly support CTAD in ArrayRef

[Mogball]

Summary

ArrayRef and MutableArrayRef need to explicitly declare support for CTAD,
otherwise uses of it trigger -Wctad-maybe-unsupported which was recently
enabled in LLVM in D131727

[dblaikie]

Guess this might let us remove makeArrayRef/makeMutableArrayRef at some point?

Also, looks like this was sent for review, then abandoned and
committed without review? Generally if something's sent for review it
should not be submitted until the review is completed (we don't want
to create situations where people send things for review because they
need review, but then submit them due to lack of feedback in the
review)

[Mogball]

This should not have been submitted. I just abandoned the patch because I'm not sure this was the right direction.

[Mogball]

I doubled checked the repo, and indeed this patch was not accidentally committed

[dblaikie]

In D132159#3741108, @Mogball wrote:

This should not have been submitted. I just abandoned the patch because I'm not sure this was the right direction.

Ah, OK - I think I'd be OK with this direction, FWIW, but haven't considered all the nuances.

In D132159#3741114, @Mogball wrote:

I doubled checked the repo, and indeed this patch was not accidentally committed

Oh, indeed - sorry, I thought I was reading a commit that referenced phab, instead of just a phab review.

llvm/include/llvm/ADT/ArrayRef.h

#endif
     /// @{
     operator std::vector<T>() const {
       return std::vector<T>(Data, Data+Length);
     }
 
     /// @}
   };
 
+  /// Explicitly support class template argument deduction.
+  template <typename T>
+  ArrayRef(const T &) -> ArrayRef<T>;
+
   /// MutableArrayRef - Represent a mutable 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 and modify 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 MutableArrayRef. For this reason, it is not in
public:
     /// @name Operator Overloads
     /// @{
     T &operator[](size_t Index) const {
       assert(Index < this->size() && "Invalid index!");
       return data()[Index];
     }
   };
 
+  /// Explicitly support class template argument deduction.
+  template <typename T>
+  MutableArrayRef(T &) -> MutableArrayRef<T>;
+
   /// This is a MutableArrayRef that owns its array.
   template <typename T> class OwningArrayRef : public MutableArrayRef<T> {
   public:
     OwningArrayRef() = default;
     OwningArrayRef(size_t Size) : MutableArrayRef<T>(new T[Size], Size) {}
 
     OwningArrayRef(ArrayRef<T> Data)
         : MutableArrayRef<T>(new T[Data.size()], Data.size()) {