[ADT] clang-format several files (NFC)

kazutakahirata · kazutakahirata · commit df2a7a9ec9af · 2025-09-11T22:16:11.000-07:00
I'm planning to modify these files.
diff --git a/llvm/include/llvm/ADT/IndexedMap.h b/llvm/include/llvm/ADT/IndexedMap.h
@@ -20,67 +20,56 @@
 #ifndef LLVM_ADT_INDEXEDMAP_H
 #define LLVM_ADT_INDEXEDMAP_H
 
-#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/identity.h"
 #include <cassert>
 
 namespace llvm {
 
-template <typename T, typename ToIndexT = identity<unsigned>>
-  class IndexedMap {
-    using IndexT = typename ToIndexT::argument_type;
-    // Prefer SmallVector with zero inline storage over std::vector. IndexedMaps
-    // can grow very large and SmallVector grows more efficiently as long as T
-    // is trivially copyable.
-    using StorageT = SmallVector<T, 0>;
-
-    StorageT storage_;
-    T nullVal_;
-    ToIndexT toIndex_;
-
-  public:
-    IndexedMap() : nullVal_(T()) {}
-
-    explicit IndexedMap(const T& val) : nullVal_(val) {}
-
-    typename StorageT::reference operator[](IndexT n) {
-      assert(toIndex_(n) < storage_.size() && "index out of bounds!");
-      return storage_[toIndex_(n)];
-    }
-
-    typename StorageT::const_reference operator[](IndexT n) const {
-      assert(toIndex_(n) < storage_.size() && "index out of bounds!");
-      return storage_[toIndex_(n)];
-    }
-
-    void reserve(typename StorageT::size_type s) {
-      storage_.reserve(s);
-    }
-
-    void resize(typename StorageT::size_type s) {
-      storage_.resize(s, nullVal_);
-    }
-
-    void clear() {
-      storage_.clear();
-    }
-
-    void grow(IndexT n) {
-      unsigned NewSize = toIndex_(n) + 1;
-      if (NewSize > storage_.size())
-        resize(NewSize);
-    }
-
-    bool inBounds(IndexT n) const {
-      return toIndex_(n) < storage_.size();
-    }
-
-    typename StorageT::size_type size() const {
-      return storage_.size();
-    }
-  };
-
-} // end namespace llvm
+template <typename T, typename ToIndexT = identity<unsigned>> class IndexedMap {
+  using IndexT = typename ToIndexT::argument_type;
+  // Prefer SmallVector with zero inline storage over std::vector. IndexedMaps
+  // can grow very large and SmallVector grows more efficiently as long as T
+  // is trivially copyable.
+  using StorageT = SmallVector<T, 0>;
+
+  StorageT storage_;
+  T nullVal_;
+  ToIndexT toIndex_;
+
+public:
+  IndexedMap() : nullVal_(T()) {}
+
+  explicit IndexedMap(const T &val) : nullVal_(val) {}
+
+  typename StorageT::reference operator[](IndexT n) {
+    assert(toIndex_(n) < storage_.size() && "index out of bounds!");
+    return storage_[toIndex_(n)];
+  }
+
+  typename StorageT::const_reference operator[](IndexT n) const {
+    assert(toIndex_(n) < storage_.size() && "index out of bounds!");
+    return storage_[toIndex_(n)];
+  }
+
+  void reserve(typename StorageT::size_type s) { storage_.reserve(s); }
+
+  void resize(typename StorageT::size_type s) { storage_.resize(s, nullVal_); }
+
+  void clear() { storage_.clear(); }
+
+  void grow(IndexT n) {
+    unsigned NewSize = toIndex_(n) + 1;
+    if (NewSize > storage_.size())
+      resize(NewSize);
+  }
+
+  bool inBounds(IndexT n) const { return toIndex_(n) < storage_.size(); }
+
+  typename StorageT::size_type size() const { return storage_.size(); }
+};
+
+} // namespace llvm
 
 #endif // LLVM_ADT_INDEXEDMAP_H
diff --git a/llvm/include/llvm/ADT/SparseMultiSet.h b/llvm/include/llvm/ADT/SparseMultiSet.h
@@ -21,9 +21,9 @@
 #ifndef LLVM_ADT_SPARSEMULTISET_H
 #define LLVM_ADT_SPARSEMULTISET_H
 
-#include "llvm/ADT/identity.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/SparseSet.h"
+#include "llvm/ADT/identity.h"
 #include <cassert>
 #include <cstdint>
 #include <cstdlib>
@@ -80,9 +80,8 @@ namespace llvm {
 /// @tparam KeyFunctorT A functor that computes an unsigned index from KeyT.
 /// @tparam SparseT     An unsigned integer type. See above.
 ///
-template<typename ValueT,
-         typename KeyFunctorT = identity<unsigned>,
-         typename SparseT = uint8_t>
+template <typename ValueT, typename KeyFunctorT = identity<unsigned>,
+          typename SparseT = uint8_t>
 class SparseMultiSet {
   static_assert(std::is_unsigned_v<SparseT>,
                 "SparseT must be an unsigned integer type");
@@ -103,14 +102,10 @@ class SparseMultiSet {
     SMSNode(ValueT D, unsigned P, unsigned N) : Data(D), Prev(P), Next(N) {}
 
     /// List tails have invalid Nexts.
-    bool isTail() const {
-      return Next == INVALID;
-    }
+    bool isTail() const { return Next == INVALID; }
 
     /// Whether this node is a tombstone node, and thus is in our freelist.
-    bool isTombstone() const {
-      return Prev == INVALID;
-    }
+    bool isTombstone() const { return Prev == INVALID; }
 
     /// Since the list is circular in Prev, all non-tombstone nodes have a valid
     /// Prev.
@@ -156,7 +151,7 @@ class SparseMultiSet {
 
   /// Add in the given SMSNode. Uses a free entry in our freelist if
   /// available. Returns the index of the added node.
-  unsigned addValue(const ValueT& V, unsigned Prev, unsigned Next) {
+  unsigned addValue(const ValueT &V, unsigned Prev, unsigned Next) {
     if (NumFree == 0) {
       Dense.push_back(SMSNode(V, Prev, Next));
       return Dense.size() - 1;
@@ -204,13 +199,13 @@ class SparseMultiSet {
     // seem like a likely use case, so we can add that code when we need it.
     assert(empty() && "Can only resize universe on an empty map");
     // Hysteresis prevents needless reallocations.
-    if (U >= Universe/4 && U <= Universe)
+    if (U >= Universe / 4 && U <= Universe)
       return;
     free(Sparse);
     // The Sparse array doesn't actually need to be initialized, so malloc
     // would be enough here, but that will cause tools like valgrind to
     // complain about branching on uninitialized data.
-    Sparse = static_cast<SparseT*>(safe_calloc(U, sizeof(SparseT)));
+    Sparse = static_cast<SparseT *>(safe_calloc(U, sizeof(SparseT)));
     Universe = U;
   }
 
@@ -232,7 +227,7 @@ class SparseMultiSet {
     unsigned SparseIdx;
 
     iterator_base(SMSPtrTy P, unsigned I, unsigned SI)
-      : SMS(P), Idx(I), SparseIdx(SI) {}
+        : SMS(P), Idx(I), SparseIdx(SI) {}
 
     /// Whether our iterator has fallen outside our dense vector.
     bool isEnd() const {
@@ -273,9 +268,7 @@ class SparseMultiSet {
       return false;
     }
 
-    bool operator!=(const iterator_base &RHS) const {
-      return !operator==(RHS);
-    }
+    bool operator!=(const iterator_base &RHS) const { return !operator==(RHS); }
 
     /// Increment and decrement operators
     iterator_base &operator--() { // predecrement - Back up
@@ -372,12 +365,10 @@ class SparseMultiSet {
   /// @param   Key A valid key to find.
   /// @returns An iterator to the element identified by key, or end().
   ///
-  iterator find(const KeyT &Key) {
-    return findIndex(KeyIndexOf(Key));
-  }
+  iterator find(const KeyT &Key) { return findIndex(KeyIndexOf(Key)); }
 
   const_iterator find(const KeyT &Key) const {
-    iterator I = const_cast<SparseMultiSet*>(this)->findIndex(KeyIndexOf(Key));
+    iterator I = const_cast<SparseMultiSet *>(this)->findIndex(KeyIndexOf(Key));
     return const_iterator(I.SMS, I.Idx, KeyIndexOf(Key));
   }
 
@@ -392,9 +383,7 @@ class SparseMultiSet {
   }
 
   /// Returns true if this set contains an element identified by Key.
-  bool contains(const KeyT &Key) const {
-    return find(Key) != end();
-  }
+  bool contains(const KeyT &Key) const { return find(Key) != end(); }
 
   /// Return the head and tail of the subset's list, otherwise returns end().
   iterator getHead(const KeyT &Key) { return find(Key); }
@@ -517,6 +506,6 @@ class SparseMultiSet {
   }
 };
 
-} // end namespace llvm
+} // namespace llvm
 
 #endif // LLVM_ADT_SPARSEMULTISET_H
diff --git a/llvm/include/llvm/ADT/SparseSet.h b/llvm/include/llvm/ADT/SparseSet.h
@@ -20,8 +20,8 @@
 #ifndef LLVM_ADT_SPARSESET_H
 #define LLVM_ADT_SPARSESET_H
 
-#include "llvm/ADT/identity.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/identity.h"
 #include "llvm/Support/AllocatorBase.h"
 #include <cassert>
 #include <cstdint>
@@ -53,8 +53,7 @@ namespace llvm {
 ///
 /// For best results, ValueT should not require a destructor.
 ///
-template<typename ValueT>
-struct SparseSetValTraits {
+template <typename ValueT> struct SparseSetValTraits {
   static unsigned getValIndex(const ValueT &Val) {
     return Val.getSparseSetIndex();
   }
@@ -64,7 +63,7 @@ struct SparseSetValTraits {
 /// generic implementation handles ValueT classes which either provide
 /// getSparseSetIndex() or specialize SparseSetValTraits<>.
 ///
-template<typename KeyT, typename ValueT, typename KeyFunctorT>
+template <typename KeyT, typename ValueT, typename KeyFunctorT>
 struct SparseSetValFunctor {
   unsigned operator()(const ValueT &Val) const {
     return SparseSetValTraits<ValueT>::getValIndex(Val);
@@ -73,11 +72,9 @@ struct SparseSetValFunctor {
 
 /// SparseSetValFunctor<KeyT, KeyT> - Helper class for the common case of
 /// identity key/value sets.
-template<typename KeyT, typename KeyFunctorT>
+template <typename KeyT, typename KeyFunctorT>
 struct SparseSetValFunctor<KeyT, KeyT, KeyFunctorT> {
-  unsigned operator()(const KeyT &Key) const {
-    return KeyFunctorT()(Key);
-  }
+  unsigned operator()(const KeyT &Key) const { return KeyFunctorT()(Key); }
 };
 
 /// SparseSet - Fast set implementation for objects that can be identified by
@@ -118,9 +115,8 @@ struct SparseSetValFunctor<KeyT, KeyT, KeyFunctorT> {
 /// @tparam KeyFunctorT A functor that computes an unsigned index from KeyT.
 /// @tparam SparseT     An unsigned integer type. See above.
 ///
-template<typename ValueT,
-         typename KeyFunctorT = identity<unsigned>,
-         typename SparseT = uint8_t>
+template <typename ValueT, typename KeyFunctorT = identity<unsigned>,
+          typename SparseT = uint8_t>
 class SparseSet {
   static_assert(std::is_unsigned_v<SparseT>,
                 "SparseT must be an unsigned integer type");
@@ -162,7 +158,7 @@ class SparseSet {
     // seem like a likely use case, so we can add that code when we need it.
     assert(empty() && "Can only resize universe on an empty map");
     // Hysteresis prevents needless reallocations.
-    if (U >= Universe/4 && U <= Universe)
+    if (U >= Universe / 4 && U <= Universe)
       return;
     // The Sparse array doesn't actually need to be initialized, so malloc
     // would be enough here, but that will cause tools like valgrind to
@@ -226,12 +222,10 @@ class SparseSet {
   /// @param   Key A valid key to find.
   /// @returns An iterator to the element identified by key, or end().
   ///
-  iterator find(const KeyT &Key) {
-    return findIndex(KeyIndexOf(Key));
-  }
+  iterator find(const KeyT &Key) { return findIndex(KeyIndexOf(Key)); }
 
   const_iterator find(const KeyT &Key) const {
-    return const_cast<SparseSet*>(this)->findIndex(KeyIndexOf(Key));
+    return const_cast<SparseSet *>(this)->findIndex(KeyIndexOf(Key));
   }
 
   /// Check if the set contains the given \c Key.
@@ -267,9 +261,7 @@ class SparseSet {
   /// array subscript - If an element already exists with this key, return it.
   /// Otherwise, automatically construct a new value from Key, insert it,
   /// and return the newly inserted element.
-  ValueT &operator[](const KeyT &Key) {
-    return *insert(ValueT(Key)).first;
-  }
+  ValueT &operator[](const KeyT &Key) { return *insert(ValueT(Key)).first; }
 
   ValueT pop_back_val() {
     // Sparse does not need to be cleared, see find().
@@ -318,6 +310,6 @@ class SparseSet {
   }
 };
 
-} // end namespace llvm
+} // namespace llvm
 
 #endif // LLVM_ADT_SPARSESET_H
diff --git a/llvm/include/llvm/ADT/identity.h b/llvm/include/llvm/ADT/identity.h
@@ -15,22 +15,17 @@
 #ifndef LLVM_ADT_IDENTITY_H
 #define LLVM_ADT_IDENTITY_H
 
-
 namespace llvm {
 
 // Similar to `std::identity` from C++20.
 template <class Ty> struct identity {
   using is_transparent = void;
   using argument_type = Ty;
 
-  Ty &operator()(Ty &self) const {
-    return self;
-  }
-  const Ty &operator()(const Ty &self) const {
-    return self;
-  }
+  Ty &operator()(Ty &self) const { return self; }
+  const Ty &operator()(const Ty &self) const { return self; }
 };
 
-} // end namespace llvm
+} // namespace llvm
 
 #endif // LLVM_ADT_IDENTITY_H
