Remove code only needed to detect a pre-4.0 API break.

[resistor]

Summary

Updated with build fix for unit tests

[dexonsmith]

LGTM

llvm/include/llvm/ADT/ilist.h

 ///
 /// Customize callbacks and allocation semantics.
 template <typename NodeTy>
 struct ilist_traits : public ilist_node_traits<NodeTy> {};
 
 /// Const traits should never be instantiated.
 template <typename Ty> struct ilist_traits<const Ty> {};
 
-namespace ilist_detail {
-
-template <class T> T &make();
-
-/// Type trait to check for a traits class that has a getNext member (as a
-/// canary for any of the ilist_nextprev_traits API).
-template <class TraitsT, class NodeT> struct HasGetNext {
-  typedef char Yes[1];
-  typedef char No[2];
-  template <size_t N> struct SFINAE {};
-
-  template <class U>
-  static Yes &test(U *I, decltype(I->getNext(&make<NodeT>())) * = nullptr);
-  template <class> static No &test(...);
-
-public:
-  static const bool value = sizeof(test<TraitsT>(nullptr)) == sizeof(Yes);
-};
-
-/// Type trait to check for a traits class that has a createSentinel member (as
-/// a canary for any of the ilist_sentinel_traits API).
-template <class TraitsT> struct HasCreateSentinel {
-  typedef char Yes[1];
-  typedef char No[2];
-
-  template <class U>
-  static Yes &test(U *I, decltype(I->createSentinel()) * = nullptr);
-  template <class> static No &test(...);
-
-public:
-  static const bool value = sizeof(test<TraitsT>(nullptr)) == sizeof(Yes);
-};
-
-/// Type trait to check for a traits class that has a createNode member.
-/// Allocation should be managed in a wrapper class, instead of in
-/// ilist_traits.
-template <class TraitsT, class NodeT> struct HasCreateNode {
-  typedef char Yes[1];
-  typedef char No[2];
-  template <size_t N> struct SFINAE {};
-
-  template <class U>
-  static Yes &test(U *I, decltype(I->createNode(make<NodeT>())) * = 0);
-  template <class> static No &test(...);
-
-public:
-  static const bool value = sizeof(test<TraitsT>(nullptr)) == sizeof(Yes);
-};
-
-template <class TraitsT, class NodeT> struct HasObsoleteCustomization {
-  static const bool value = HasGetNext<TraitsT, NodeT>::value ||
-                            HasCreateSentinel<TraitsT>::value ||
-                            HasCreateNode<TraitsT, NodeT>::value;
-};
-
-} // end namespace ilist_detail
-
 //===----------------------------------------------------------------------===//
 //
 /// A wrapper around an intrusive list with callbacks and non-intrusive
 /// ownership.
 ///
 /// This wraps a purely intrusive list (like simple_ilist) with a configurable
 /// traits class.  The traits can implement callbacks and customize the
 /// ownership semantics.
public:
   typedef typename base_list_type::difference_type difference_type;
   typedef typename base_list_type::iterator iterator;
   typedef typename base_list_type::const_iterator const_iterator;
   typedef typename base_list_type::reverse_iterator reverse_iterator;
   typedef
       typename base_list_type::const_reverse_iterator const_reverse_iterator;
 
 private:
-  // TODO: Drop this assertion and the transitive type traits anytime after
-  // v4.0 is branched (i.e,. keep them for one release to help out-of-tree code
-  // update).
-  static_assert(
-      !ilist_detail::HasObsoleteCustomization<TraitsT, value_type>::value,
-      "ilist customization points have changed!");
-
   static bool op_less(const_reference L, const_reference R) { return L < R; }
   static bool op_equal(const_reference L, const_reference R) { return L == R; }
 
 public:
   iplist_impl() = default;
 
   iplist_impl(const iplist_impl &) = delete;
   iplist_impl &operator=(const iplist_impl &) = delete;

llvm/unittests/ADT/IListTest.cpp

TEST(IListTest, UnsafeClear) {
   // List is still functional.
   List.push_back(new Node(5));
   List.push_back(new Node(6));
   ASSERT_EQ(2u, List.size());
   EXPECT_EQ(5, List.front().Value);
   EXPECT_EQ(6, List.back().Value);
 }
 
-struct Empty {};
-TEST(IListTest, HasObsoleteCustomizationTrait) {
-  // Negative test for HasObsoleteCustomization.
-  static_assert(!ilist_detail::HasObsoleteCustomization<Empty, Node>::value,
-                "Empty has no customizations");
-}
-
-struct GetNext {
-  Node *getNext(Node *);
-};
-TEST(IListTest, HasGetNextTrait) {
-  static_assert(ilist_detail::HasGetNext<GetNext, Node>::value,
-                "GetNext has a getNext(Node*)");
-  static_assert(ilist_detail::HasObsoleteCustomization<GetNext, Node>::value,
-                "Empty should be obsolete because of getNext()");
-
-  // Negative test for HasGetNext.
-  static_assert(!ilist_detail::HasGetNext<Empty, Node>::value,
-                "Empty does not have a getNext(Node*)");
-}
-
-struct CreateSentinel {
-  Node *createSentinel();
-};
-TEST(IListTest, HasCreateSentinelTrait) {
-  static_assert(ilist_detail::HasCreateSentinel<CreateSentinel>::value,
-                "CreateSentinel has a getNext(Node*)");
-  static_assert(
-      ilist_detail::HasObsoleteCustomization<CreateSentinel, Node>::value,
-      "Empty should be obsolete because of createSentinel()");
-
-  // Negative test for HasCreateSentinel.
-  static_assert(!ilist_detail::HasCreateSentinel<Empty>::value,
-                "Empty does not have a createSentinel()");
-}
-
 struct NodeWithCallback : ilist_node<NodeWithCallback> {
   int Value = 0;
   bool IsInList = false;
   bool WasTransferred = false;
 
   NodeWithCallback() = default;
   NodeWithCallback(int Value) : Value(Value) {}
   NodeWithCallback(const NodeWithCallback &) = delete;