Revert "Re-import LLVMSupport from llvm-project and enforce header includes only being used from the Swift fork when building stdlib (swiftlang#40173)"

This reverts commit 7e33575.

Author: kubamracek

include/swift/AST/Decl.h

@@ -207,9 +207,6 @@ enum class AssociatedValueCheck {
 /// Diagnostic printing of \c StaticSpellingKind.
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, StaticSpellingKind SSK);
 
-/// Diagnostic printing of \c ReferenceOwnership.
-llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, ReferenceOwnership RO);
-
 /// Encapsulation of the overload signature of a given declaration,
 /// which is used to determine uniqueness of a declaration within a
 /// given context.

include/swift/AST/LayoutConstraintKind.h

@@ -14,7 +14,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include <cstdint>
+#include "llvm/Support/DataTypes.h"
 
 #ifndef SWIFT_LAYOUT_CONSTRAINTKIND_H
 #define SWIFT_LAYOUT_CONSTRAINTKIND_H

include/swift/AST/Ownership.h

@@ -23,6 +23,7 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/raw_ostream.h"
 #include <assert.h>
 #include <limits.h>
 #include <stdint.h>
@@ -117,6 +118,9 @@ optionalityOf(ReferenceOwnership ownership) {
   llvm_unreachable("impossible");
 }
 
+/// Diagnostic printing of \c StaticSpellingKind.
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, ReferenceOwnership RO);
+
 /// Different kinds of value ownership supported by Swift.
 enum class ValueOwnership : uint8_t {
   /// the context-dependent default ownership (sometimes shared,

stdlib/CMakeLists.txt

@@ -178,13 +178,6 @@ set(SWIFT_CONCURRENCY_GLOBAL_EXECUTOR
 # End of user-configurable options.
 #
 
-# Remove llvm-project/llvm/include directory from -I search part when building
-# the stdlib. We have our own fork of LLVM includes (Support, ADT) in
-# stdlib/include/llvm and we don't want to silently use headers from LLVM.
-get_property(stdlib_include_directories DIRECTORY PROPERTY INCLUDE_DIRECTORIES)
-list(REMOVE_ITEM stdlib_include_directories "${LLVM_MAIN_INCLUDE_DIR}")
-set_property(DIRECTORY PROPERTY INCLUDE_DIRECTORIES ${stdlib_include_directories})
-
 include(AddSwiftStdlib)
 
 # Create convenience targets for the Swift standard library.

stdlib/include/llvm/ADT/ArrayRef.h

@@ -27,8 +27,6 @@
 inline namespace __swift { inline namespace __runtime {
 namespace llvm {
 
-  template<typename T> struct DenseMapInfo;
-
   /// 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.
@@ -43,17 +41,10 @@ namespace llvm {
   template<typename T>
   class LLVM_GSL_POINTER LLVM_NODISCARD ArrayRef {
   public:
-    using value_type = T;
-    using pointer = value_type *;
-    using const_pointer = const value_type *;
-    using reference = value_type &;
-    using const_reference = const value_type &;
-    using iterator = const_pointer;
-    using const_iterator = const_pointer;
-    using reverse_iterator = std::reverse_iterator<iterator>;
-    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+    using iterator = const T *;
+    using const_iterator = const T *;
     using size_type = size_t;
-    using difference_type = ptrdiff_t;
+    using reverse_iterator = std::reverse_iterator<iterator>;
 
   private:
     /// The start of the array, in an external buffer.
@@ -307,17 +298,8 @@ namespace llvm {
   template<typename T>
   class LLVM_NODISCARD MutableArrayRef : public ArrayRef<T> {
   public:
-    using value_type = T;
-    using pointer = value_type *;
-    using const_pointer = const value_type *;
-    using reference = value_type &;
-    using const_reference = const value_type &;
-    using iterator = pointer;
-    using const_iterator = const_pointer;
+    using iterator = T *;
     using reverse_iterator = std::reverse_iterator<iterator>;
-    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-    using size_type = size_t;
-    using difference_type = ptrdiff_t;
 
     /// Construct an empty MutableArrayRef.
     /*implicit*/ MutableArrayRef() = default;
@@ -572,35 +554,6 @@ namespace llvm {
     return hash_combine_range(S.begin(), S.end());
   }
 
-  // Provide DenseMapInfo for ArrayRefs.
-  template <typename T> struct DenseMapInfo<ArrayRef<T>> {
-    static inline ArrayRef<T> getEmptyKey() {
-      return ArrayRef<T>(
-          reinterpret_cast<const T *>(~static_cast<uintptr_t>(0)), size_t(0));
-    }
-
-    static inline ArrayRef<T> getTombstoneKey() {
-      return ArrayRef<T>(
-          reinterpret_cast<const T *>(~static_cast<uintptr_t>(1)), size_t(0));
-    }
-
-    static unsigned getHashValue(ArrayRef<T> Val) {
-      assert(Val.data() != getEmptyKey().data() &&
-             "Cannot hash the empty key!");
-      assert(Val.data() != getTombstoneKey().data() &&
-             "Cannot hash the tombstone key!");
-      return (unsigned)(hash_value(Val));
-    }
-
-    static bool isEqual(ArrayRef<T> LHS, ArrayRef<T> RHS) {
-      if (RHS.data() == getEmptyKey().data())
-        return LHS.data() == getEmptyKey().data();
-      if (RHS.data() == getTombstoneKey().data())
-        return LHS.data() == getTombstoneKey().data();
-      return LHS == RHS;
-    }
-  };
-
 } // end namespace llvm
 }} // namespace swift::runtime
 

stdlib/include/llvm/ADT/DenseMap.h

@@ -381,8 +381,8 @@ class DenseMapBase {
     setNumEntries(other.getNumEntries());
     setNumTombstones(other.getNumTombstones());
 
-    if (std::is_trivially_copyable<KeyT>::value &&
-        std::is_trivially_copyable<ValueT>::value)
+    if (is_trivially_copyable<KeyT>::value &&
+        is_trivially_copyable<ValueT>::value)
       memcpy(reinterpret_cast<void *>(getBuckets()), other.getBuckets(),
              getNumBuckets() * sizeof(BucketT));
     else
@@ -667,7 +667,7 @@ class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
   unsigned NumBuckets;
 
 public:
-  /// Create a DenseMap with an optional \p InitialReserve that guarantee that
+  /// Create a DenseMap wth an optional \p InitialReserve that guarantee that
   /// this number of elements can be inserted in the map without grow()
   explicit DenseMap(unsigned InitialReserve = 0) { init(InitialReserve); }
 
@@ -864,9 +864,6 @@ class SmallDenseMap
     this->insert(I, E);
   }
 
-  SmallDenseMap(std::initializer_list<typename BaseT::value_type> Vals)
-      : SmallDenseMap(Vals.begin(), Vals.end()) {}
-
   ~SmallDenseMap() {
     this->destroyAll();
     deallocateBuckets();
@@ -897,7 +894,7 @@ class SmallDenseMap
           std::swap(*LHSB, *RHSB);
           continue;
         }
-        // Swap separately and handle any asymmetry.
+        // Swap separately and handle any assymetry.
         std::swap(LHSB->getFirst(), RHSB->getFirst());
         if (hasLHSValue) {
           ::new (&RHSB->getSecond()) ValueT(std::move(LHSB->getSecond()));
@@ -985,7 +982,7 @@ class SmallDenseMap
     if (Small) {
       // First move the inline buckets into a temporary storage.
       AlignedCharArrayUnion<BucketT[InlineBuckets]> TmpStorage;
-      BucketT *TmpBegin = reinterpret_cast<BucketT *>(&TmpStorage);
+      BucketT *TmpBegin = reinterpret_cast<BucketT *>(TmpStorage.buffer);
       BucketT *TmpEnd = TmpBegin;
 
       // Loop over the buckets, moving non-empty, non-tombstones into the
@@ -1075,8 +1072,8 @@ class SmallDenseMap
     assert(Small);
     // Note that this cast does not violate aliasing rules as we assert that
     // the memory's dynamic type is the small, inline bucket buffer, and the
-    // 'storage' is a POD containing a char buffer.
-    return reinterpret_cast<const BucketT *>(&storage);
+    // 'storage.buffer' static type is 'char *'.
+    return reinterpret_cast<const BucketT *>(storage.buffer);
   }
 
   BucketT *getInlineBuckets() {
@@ -1087,7 +1084,7 @@ class SmallDenseMap
   const LargeRep *getLargeRep() const {
     assert(!Small);
     // Note, same rule about aliasing as with getInlineBuckets.
-    return reinterpret_cast<const LargeRep *>(&storage);
+    return reinterpret_cast<const LargeRep *>(storage.buffer);
   }
 
   LargeRep *getLargeRep() {
@@ -1133,6 +1130,8 @@ class DenseMapIterator {
   friend class DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
   friend class DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, false>;
 
+  using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
+
 public:
   using difference_type = ptrdiff_t;
   using value_type =
@@ -1172,14 +1171,11 @@ class DenseMapIterator {
     return Ptr;
   }
 
-  friend bool operator==(const DenseMapIterator &LHS,
-                         const DenseMapIterator &RHS) {
-    return LHS.Ptr == RHS.Ptr;
+  bool operator==(const ConstIterator &RHS) const {
+    return Ptr == RHS.Ptr;
   }
-
-  friend bool operator!=(const DenseMapIterator &LHS,
-                         const DenseMapIterator &RHS) {
-    return !(LHS == RHS);
+  bool operator!=(const ConstIterator &RHS) const {
+    return Ptr != RHS.Ptr;
   }
 
   inline DenseMapIterator& operator++() {  // Preincrement

stdlib/include/llvm/ADT/DenseMapInfo.h

@@ -13,11 +13,12 @@
 #ifndef LLVM_ADT_DENSEMAPINFO_H
 #define LLVM_ADT_DENSEMAPINFO_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/StringRef.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
-#include <tuple>
 #include <utility>
 
 inline namespace __swift { inline namespace __runtime {
@@ -256,7 +257,7 @@ template <typename... Ts> struct DenseMapInfo<std::tuple<Ts...>> {
   }
 
   template <unsigned I>
-  static unsigned getHashValueImpl(const Tuple &, std::true_type) {
+  static unsigned getHashValueImpl(const Tuple &values, std::true_type) {
     return 0;
   }
 
@@ -274,7 +275,7 @@ template <typename... Ts> struct DenseMapInfo<std::tuple<Ts...>> {
   }
 
   template <unsigned I>
-  static bool isEqualImpl(const Tuple &, const Tuple &, std::true_type) {
+  static bool isEqualImpl(const Tuple &lhs, const Tuple &rhs, std::true_type) {
     return true;
   }
 
@@ -284,6 +285,62 @@ template <typename... Ts> struct DenseMapInfo<std::tuple<Ts...>> {
   }
 };
 
+// Provide DenseMapInfo for StringRefs.
+template <> struct DenseMapInfo<StringRef> {
+  static inline StringRef getEmptyKey() {
+    return StringRef(reinterpret_cast<const char *>(~static_cast<uintptr_t>(0)),
+                     0);
+  }
+
+  static inline StringRef getTombstoneKey() {
+    return StringRef(reinterpret_cast<const char *>(~static_cast<uintptr_t>(1)),
+                     0);
+  }
+
+  static unsigned getHashValue(StringRef Val) {
+    assert(Val.data() != getEmptyKey().data() && "Cannot hash the empty key!");
+    assert(Val.data() != getTombstoneKey().data() &&
+           "Cannot hash the tombstone key!");
+    return (unsigned)(hash_value(Val));
+  }
+
+  static bool isEqual(StringRef LHS, StringRef RHS) {
+    if (RHS.data() == getEmptyKey().data())
+      return LHS.data() == getEmptyKey().data();
+    if (RHS.data() == getTombstoneKey().data())
+      return LHS.data() == getTombstoneKey().data();
+    return LHS == RHS;
+  }
+};
+
+// Provide DenseMapInfo for ArrayRefs.
+template <typename T> struct DenseMapInfo<ArrayRef<T>> {
+  static inline ArrayRef<T> getEmptyKey() {
+    return ArrayRef<T>(reinterpret_cast<const T *>(~static_cast<uintptr_t>(0)),
+                       size_t(0));
+  }
+
+  static inline ArrayRef<T> getTombstoneKey() {
+    return ArrayRef<T>(reinterpret_cast<const T *>(~static_cast<uintptr_t>(1)),
+                       size_t(0));
+  }
+
+  static unsigned getHashValue(ArrayRef<T> Val) {
+    assert(Val.data() != getEmptyKey().data() && "Cannot hash the empty key!");
+    assert(Val.data() != getTombstoneKey().data() &&
+           "Cannot hash the tombstone key!");
+    return (unsigned)(hash_value(Val));
+  }
+
+  static bool isEqual(ArrayRef<T> LHS, ArrayRef<T> RHS) {
+    if (RHS.data() == getEmptyKey().data())
+      return LHS.data() == getEmptyKey().data();
+    if (RHS.data() == getTombstoneKey().data())
+      return LHS.data() == getTombstoneKey().data();
+    return LHS == RHS;
+  }
+};
+
 template <> struct DenseMapInfo<hash_code> {
   static inline hash_code getEmptyKey() { return hash_code(-1); }
   static inline hash_code getTombstoneKey() { return hash_code(-2); }

stdlib/include/llvm/ADT/DenseSet.h

@@ -131,12 +131,8 @@ class DenseSetImpl {
 
     Iterator& operator++() { ++I; return *this; }
     Iterator operator++(int) { auto T = *this; ++I; return T; }
-    friend bool operator==(const Iterator &X, const Iterator &Y) {
-      return X.I == Y.I;
-    }
-    friend bool operator!=(const Iterator &X, const Iterator &Y) {
-      return X.I != Y.I;
-    }
+    bool operator==(const ConstIterator& X) const { return I == X.I; }
+    bool operator!=(const ConstIterator& X) const { return I != X.I; }
   };
 
   class ConstIterator {
@@ -160,12 +156,8 @@ class DenseSetImpl {
 
     ConstIterator& operator++() { ++I; return *this; }
     ConstIterator operator++(int) { auto T = *this; ++I; return T; }
-    friend bool operator==(const ConstIterator &X, const ConstIterator &Y) {
-      return X.I == Y.I;
-    }
-    friend bool operator!=(const ConstIterator &X, const ConstIterator &Y) {
-      return X.I != Y.I;
-    }
+    bool operator==(const ConstIterator& X) const { return I == X.I; }
+    bool operator!=(const ConstIterator& X) const { return I != X.I; }
   };
 
   using iterator = Iterator;
@@ -182,11 +174,6 @@ class DenseSetImpl {
     return ConstIterator(TheMap.find(V));
   }
 
-  /// Check if the set contains the given element.
-  bool contains(const_arg_type_t<ValueT> V) const {
-    return TheMap.find(V) != TheMap.end();
-  }
-
   /// Alternative version of find() which allows a different, and possibly less
   /// expensive, key type.
   /// The DenseMapInfo is responsible for supplying methods