[llvm] Declare llvm::makeArrayRef as obsolete

[serge-sans-paille]

Summary

Also cleans up a few remaining references.

This is the final commit for the series started by https://reviews.llvm.org/D140896

[serge-sans-paille]

Closed by 36117cc46388d677359f1180bd536f80d0c5fe97, sorry I forgot to add the Differential Revision tag there.

llvm/include/llvm/ADT/ArrayRef.h

#endif
 
   /// Deduction guide to construct an ArrayRef from a std::vector
   template <typename T> ArrayRef(const std::vector<T> &Vec) -> ArrayRef<T>;
 
   /// Deduction guide to construct an ArrayRef from a std::array
   template <typename T, std::size_t N>
   ArrayRef(const std::array<T, N> &Vec) -> ArrayRef<T>;
 
-  /// Deduction guide to construct an ArrayRef from an ArrayRef (no-op) (const)
+  /// Deduction guide to construct an ArrayRef from an ArrayRef (const)
   template <typename T> ArrayRef(const ArrayRef<T> &Vec) -> ArrayRef<T>;
 
-  /// Deduction guide to construct an ArrayRef from an ArrayRef (no-op)
+  /// Deduction guide to construct an ArrayRef from an ArrayRef
   template <typename T> ArrayRef(ArrayRef<T> &Vec) -> ArrayRef<T>;
 
   /// Deduction guide to construct an ArrayRef from a C array.
   template <typename T, size_t N> ArrayRef(const T (&Arr)[N]) -> ArrayRef<T>;
 
   /// @}
 
   /// @name ArrayRef Convenience constructors
#endif
   template <typename T>
   LLVM_DEPRECATED("Use deduction guide instead", "ArrayRef")
   ArrayRef<T> &makeArrayRef(ArrayRef<T> &Vec) {
     return Vec;
   }
 
   /// Construct an ArrayRef from a C array.
   template <typename T, size_t N>
-  ArrayRef<T> LLVM_DEPRECATED("Use deduction guide instead", "ArrayRef")
-      makeArrayRef(const T (&Arr)[N]) {
+  LLVM_DEPRECATED("Use deduction guide instead", "ArrayRef")
+  ArrayRef<T> makeArrayRef(const T (&Arr)[N]) {
     return ArrayRef<T>(Arr);
   }
 
   /// Construct a MutableArrayRef from a single element.
   template<typename T>
   MutableArrayRef<T> makeMutableArrayRef(T &OneElt) {
     return OneElt;
   }

mlir/lib/Dialect/SPIRV/Transforms/SPIRVWebGPUTransforms.cpp

Value lowerExtendedMultiplication(Operation *mulOp, PatternRewriter &rewriter,
   auto combineDigits = [loc, cst16, &rewriter](Value low, Value high) {
     Value highBits = rewriter.create<ShiftLeftLogicalOp>(loc, high, cst16);
     return rewriter.create<BitwiseOrOp>(loc, low, highBits);
   };
   Value low = combineDigits(resultDigits[0], resultDigits[1]);
   Value high = combineDigits(resultDigits[2], resultDigits[3]);
 
   return rewriter.create<CompositeConstructOp>(
-      loc, mulOp->getResultTypes().front(), llvm::makeArrayRef({low, high}));
+      loc, mulOp->getResultTypes().front(), llvm::ArrayRef({low, high}));
 }
 
 //===----------------------------------------------------------------------===//
 // Rewrite Patterns
 //===----------------------------------------------------------------------===//
 
 template <typename MulExtendedOp, bool SignExtendArguments>
 struct ExpandMulExtendedPattern final : OpRewritePattern<MulExtendedOp> {

mlir/lib/Dialect/Transform/IR/TransformInterfaces.cpp

 void transform::TransformResults::setParams(
     OpResult value, ArrayRef<transform::TransformState::Param> params) {
   int64_t position = value.getResultNumber();
   assert(position < static_cast<int64_t>(paramSegments.size()) &&
          "setting params for a non-existent handle");
   assert(paramSegments[position].data() == nullptr && "params already set");
   size_t start = this->params.size();
   llvm::append_range(this->params, params);
-  paramSegments[position] = makeArrayRef(this->params).drop_front(start);
+  paramSegments[position] = ArrayRef(this->params).drop_front(start);
 }
 
 ArrayRef<Operation *>
 transform::TransformResults::get(unsigned resultNumber) const {
   assert(resultNumber < segments.size() &&
          "querying results for a non-existent handle");
   assert(segments[resultNumber].data() != nullptr &&
          "querying unset results (param expected?)");