Interoperability improvements with stdlib CPP types

[rickmark]

Summary

Improves the API surface of LLVM to interoperate with C++17 and C++20
standard library types.

[rickmark]

Use standards based detection for span

[rickmark]

Fixes for clang format

llvm/include/llvm/ADT/ArrayRef.h

 #include <cassert>
 #include <cstddef>
 #include <initializer_list>
 #include <iterator>
 #include <memory>
 #include <type_traits>
 #include <vector>
 
+#if __cpp_lib_span
+#include <span>
+#endif
+
 namespace llvm {
   template<typename T> class [[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
#endif
     /// Construct an ArrayRef<const T*> from std::vector<T*>. This uses SFINAE
     /// to ensure that only vectors of pointers can be converted.
     template <typename U, typename A>
     ArrayRef(const std::vector<U *, A> &Vec,
              std::enable_if_t<std::is_convertible<U *const *, T const *>::value>
                  * = nullptr)
         : Data(Vec.data()), Length(Vec.size()) {}
 
+#if __cpp_lib_span
+    /// Construct an array ref from a C++ standard span
+    ArrayRef(const std::span<T> &Span)
+        : Data(Span.data()), Length(Span.size()) {}
+#endif
+
     /// @}
     /// @name Simple Operations
     /// @{
 
     iterator begin() const { return Data; }
     iterator end() const { return Data + Length; }
 
     reverse_iterator rbegin() const { return reverse_iterator(end()); }
#endif
 
     /// equals - Check for element-wise equality.
     bool equals(ArrayRef RHS) const {
       if (Length != RHS.Length)
         return false;
       return std::equal(begin(), end(), RHS.begin());
     }
 
+#if __cpp_lib_span
+    /// equals - Check for element-wise equality.
+    bool equals(std::span<T> RHS) const {
+      if (Length != RHS.Length)
+        return false;
+      return std::equal(begin(), end(), RHS.begin());
+    }
+#endif
+
     /// slice(n, m) - Chop off the first N elements of the array, and keep M
     /// elements in the array.
     ArrayRef<T> slice(size_t N, size_t M) const {
       assert(N+M <= size() && "Invalid specifier");
       return ArrayRef<T>(data()+N, M);
     }
 
     /// slice(n) - Chop off the first N elements of the array.
#endif
 
     /// @}
     /// @name Conversion operators
     /// @{
     operator std::vector<T>() const {
       return std::vector<T>(Data, Data+Length);
     }
 
+#if __cpp_lib_span
+    /// Construct an array ref from a C++ standard span
+    operator std::span<T>() { return std::span<T>(Data, Length); }
+#endif
+
     /// @}
   };
 
   /// 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.
   ///

llvm/include/llvm/ADT/StringExtras.h

 /// null string.
 inline std::vector<StringRef> toStringRefArray(const char *const *Strings) {
   std::vector<StringRef> Result;
   while (*Strings)
     Result.push_back(*Strings++);
   return Result;
 }
 
+/// Given an array of c-style strings terminated by a null pointer, construct
+/// a vector of string_views representing the same strings without the
+/// terminating null string.
+inline std::vector<std::string_view>
+toStringViewArray(const char *const *Strings) {
+  std::vector<std::string_view> Result;
+  while (*Strings)
+    Result.push_back(*Strings++);
+  return Result;
+}
+
 /// Construct a string ref from a boolean.
 inline StringRef toStringRef(bool B) { return StringRef(B ? "true" : "false"); }
 
 /// Construct a string ref from an array ref of unsigned chars.
 inline StringRef toStringRef(ArrayRef<uint8_t> Input) {
   return StringRef(reinterpret_cast<const char *>(Input.begin()), Input.size());
 }
 
 /// Construct a string ref from an array ref of unsigned chars.
+inline std::string_view toStringView(ArrayRef<uint8_t> Input) {
+  return std::string_view(reinterpret_cast<const char *>(Input.begin()),
+                          Input.size());
+}
+
+/// Construct a string ref from an array ref of unsigned chars.
 inline ArrayRef<uint8_t> arrayRefFromStringRef(StringRef Input) {
   return {Input.bytes_begin(), Input.bytes_end()};
 }
 
 /// Interpret the given character \p C as a hexadecimal digit and return its
 /// value.
 ///
 /// If \p C is not a valid hex digit, -1U is returned.

llvm/include/llvm/ADT/StringRef.h

#endif
 
     /// equals - Check for string equality, this is more efficient than
     /// compare() when the relative ordering of inequal strings isn't needed.
     [[nodiscard]] bool equals(StringRef RHS) const {
       return (Length == RHS.Length &&
               compareMemory(Data, RHS.Data, RHS.Length) == 0);
     }
 
+    /// equals - Check for string equality, this is more efficient than
+    /// compare() when the relative ordering of inequal strings isn't needed.
+    [[nodiscard]] bool equals(std::string_view RHS) const {
+      return (Length == RHS.length() &&
+              compareMemory(Data, RHS.data(), RHS.length()) == 0);
+    }
+
+    /// equals - Check for string equality, this is more efficient than
+    /// compare() when the relative ordering of inequal strings isn't needed.
+    [[nodiscard]] bool equals(const char *RHS) const {
+      return equals((StringRef)RHS);
+    }
+
+    /// equals - Check for string equality, this is more efficient than
+    /// compare() when the relative ordering of inequal strings isn't needed.
+    [[nodiscard]] bool equals(std::string RHS) const {
+      return equals((StringRef)RHS);
+    }
+
     /// Check for string equality, ignoring case.
     [[nodiscard]] bool equals_insensitive(StringRef RHS) const {
       return Length == RHS.Length && compare_insensitive(RHS) == 0;
     }
 
     /// compare - Compare two strings; the result is negative, zero, or positive
     /// if this string is lexicographically less than, equal to, or greater than
     /// the \p RHS.
#endif
   /// @{
 
   inline bool operator==(StringRef LHS, StringRef RHS) {
     return LHS.equals(RHS);
   }
 
   inline bool operator!=(StringRef LHS, StringRef RHS) { return !(LHS == RHS); }
 
+  inline bool operator==(StringRef LHS, std::string_view RHS) {
+    return LHS.equals(RHS);
+  }
+
+  inline bool operator!=(StringRef LHS, std::string_view RHS) {
+    return !(LHS == RHS);
+  }
+
+  inline bool operator==(StringRef LHS, const char *RHS) {
+    return LHS.equals((StringRef)RHS);
+  }
+
+  inline bool operator!=(StringRef LHS, const char *RHS) {
+    return !(LHS == RHS);
+  }
+
+  inline bool operator==(StringRef LHS, std::string RHS) {
+    return LHS.equals((StringRef)RHS);
+  }
+
+  inline bool operator!=(StringRef LHS, std::string RHS) {
+    return !(LHS == RHS);
+  }
+
   inline bool operator<(StringRef LHS, StringRef RHS) {
     return LHS.compare(RHS) < 0;
   }
 
   inline bool operator<=(StringRef LHS, StringRef RHS) {
     return LHS.compare(RHS) <= 0;
   }