Avoid redundant reference to isPodLike in SmallVect implementation

[serge-sans-paille]

Summary

NFC, preparatory work for isPodLike cleaning.

[• Quuxplusone]

include/llvm/ADT/SmallVector.h

188 ↗

(On Diff #175688)

I would have left this more similar to the left-hand side: i.e., replace lines 183-188 with simply

template <typename T, bool = isPodLike<T>::value>
class SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {

What you've got is equivalent, of course; but my suggestion was intended to reduce repetition, so it seems silly to add a repetition here.

242 ↗

(On Diff #175688)

I would not have changed these two lines. But you could argue that the new version is more self-documenting, so okay.

[• Quuxplusone]

My comment on D54472 didn't mention it because I thought it would be obvious, but the same pattern applies to your proposed diffs in "include/llvm/ADT/Optional.h".

[serge-sans-paille]

include/llvm/ADT/SmallVector.h

188 ↗

(On Diff #175688)

I tend to prefer explicit over implicit, thus the two specialization and forward declaration. I'd actually even prefer a std::conditional and two base classes with different names.

Anyway, I applied the modification you suggested, no need to debate too much about such details :-)

[• Quuxplusone]

LGTM, for what that's worth!

llvm/trunk/include/llvm/ADT/Optional.h

 #include <cassert>
 #include <new>
 #include <utility>
 
 namespace llvm {
 
 namespace optional_detail {
 /// Storage for any type.
-template <typename T, bool IsPodLike> struct OptionalStorage {
+template <typename T, bool = isPodLike<T>::value> struct OptionalStorage {
   AlignedCharArrayUnion<T> storage;
   bool hasVal = false;
 
   OptionalStorage() = default;
 
   OptionalStorage(const T &y) : hasVal(true) { new (storage.buffer) T(y); }
   OptionalStorage(const OptionalStorage &O) : hasVal(O.hasVal) {
     if (hasVal)
const T *getPointer() const {
     assert(hasVal);
     return reinterpret_cast<const T *>(storage.buffer);
   }
 };
 
 } // namespace optional_detail
 
 template <typename T> class Optional {
-  optional_detail::OptionalStorage<T, isPodLike<T>::value> Storage;
+  optional_detail::OptionalStorage<T> Storage;
 
 public:
   using value_type = T;
 
   constexpr Optional() {}
   constexpr Optional(NoneType) {}
 
   Optional(const T &y) : Storage(y) {}

llvm/trunk/include/llvm/ADT/SmallVector.h

public:
   const_reference back() const {
     assert(!empty());
     return end()[-1];
   }
 };
 
 /// SmallVectorTemplateBase<isPodLike = false> - This is where we put method
 /// implementations that are designed to work with non-POD-like T's.
-template <typename T, bool isPodLike>
+template <typename T, bool = isPodLike<T>::value>
 class SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
 protected:
   SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}
 
   static void destroy_range(T *S, T *E) {
     while (S != E) {
       --E;
       E->~T();
public:
   }
 
   void pop_back() { this->set_size(this->size() - 1); }
 };
 
 /// This class consists of common code factored out of the SmallVector class to
 /// reduce code duplication based on the SmallVector 'N' template parameter.
 template <typename T>
-class SmallVectorImpl : public SmallVectorTemplateBase<T, isPodLike<T>::value> {
-  using SuperClass = SmallVectorTemplateBase<T, isPodLike<T>::value>;
+class SmallVectorImpl : public SmallVectorTemplateBase<T> {
+  using SuperClass = SmallVectorTemplateBase<T>;
 
 public:
   using iterator = typename SuperClass::iterator;
   using const_iterator = typename SuperClass::const_iterator;
   using size_type = typename SuperClass::size_type;
 
 protected:
   // Default ctor - Initialize to empty.