[libcxx] [test] Workaround C1XX bug in uses_allocator_types.hpp

[CaseyCarter]

Summary

Needed by allocator.adaptor\allocator.adaptor.members\construct_pair.pass.cpp.

[CaseyCarter]

Silence warnings.

libcxx/trunk/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp

void test_no_inner_alloc()
     {
         using T = UsesAllocatorV1<VoidAlloc, 0>;
         using U = UsesAllocatorV2<VoidAlloc, 0>;
         using Pair = std::pair<T, U>;
         using Alloc = CountingAllocator<Pair>;
         using SA = std::scoped_allocator_adaptor<Alloc>;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        assert(ptr);
         Alloc CA(P);
         SA A(CA);
         A.construct(ptr);
         assert(checkConstruct<>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<>(ptr->second, UA_AllocLast, CA));
         assert((P.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SA&>&&,
                                  std::tuple<SA&>&&
               >(CA, ptr)));
         A.destroy(ptr);
         std::free(ptr);
 
     }
     P.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc, 0>;
         using U = NotUsesAllocator<VoidAlloc, 0>;
         using Pair = std::pair<T, U>;
         using Alloc = CountingAllocator<Pair>;
         using SA = std::scoped_allocator_adaptor<Alloc>;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        assert(ptr);
         Alloc CA(P);
         SA A(CA);
         A.construct(ptr);
         assert(checkConstruct<>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<>(ptr->second, UA_None));
         assert((P.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SA&>&&,
                                  std::tuple<>&&
                    >(CA, ptr)));
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 
 void test_with_inner_alloc()
 {
-    using VoidAlloc1 = CountingAllocator<void, 1>;
     using VoidAlloc2 = CountingAllocator<void, 2>;
 
     AllocController POuter;
     AllocController PInner;
     {
         using T = UsesAllocatorV1<VoidAlloc2, 0>;
         using U = UsesAllocatorV2<VoidAlloc2, 0>;
         using Pair = std::pair<T, U>;
         using Outer = CountingAllocator<Pair, 1>;
         using Inner = CountingAllocator<Pair, 2>;
         using SA = std::scoped_allocator_adaptor<Outer, Inner>;
         using SAInner = std::scoped_allocator_adaptor<Inner>;
         static_assert(!std::uses_allocator<T, Outer>::value, "");
         static_assert(std::uses_allocator<T, Inner>::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        assert(ptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         A.construct(ptr);
         assert(checkConstruct<>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<>(ptr->second, UA_AllocLast));
         assert((POuter.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SAInner&>&&,
POuter.reset();
         using Pair = std::pair<T, U>;
         using Outer = CountingAllocator<Pair, 1>;
         using Inner = CountingAllocator<Pair, 2>;
         using SA = std::scoped_allocator_adaptor<Outer, Inner>;
         using SAInner = std::scoped_allocator_adaptor<Inner>;
         static_assert(!std::uses_allocator<T, Outer>::value, "");
         static_assert(std::uses_allocator<T, Inner>::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        assert(ptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         A.construct(ptr);
         assert(checkConstruct<>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<>(ptr->second, UA_None));
         assert((POuter.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SAInner&>&&,

libcxx/trunk/test/support/test.workarounds/c1xx_empty_parameter_pack_expansion.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// Verify TEST_WORKAROUND_C1XX_EMPTY_PARAMETER_PACK_EXPANSION.
+
+#include <type_traits>
+
+#include "test_workarounds.h"
+
+template<class T>
+struct identity {
+    using type = T;
+};
+
+template<class...> struct list {};
+
+// C1XX believes this function template is not viable when LArgs is an empty
+// parameter pack.
+template <class ...LArgs>
+int f2(typename identity<LArgs>::type..., int i) {
+    return i;
+}
+
+#ifdef TEST_WORKAROUND_C1XX_EMPTY_PARAMETER_PACK_EXPANSION
+// C1XX believes this function template *is* viable when LArgs is an empty
+// parameter pack. Conforming compilers believe the two overloads are
+// ambiguous when LArgs is an empty pack.
+template <class ...LArgs>
+int f2(int i) {
+    return i;
+}
+#endif
+
+template <class ...LArgs, class ...Args>
+int f1(list<LArgs...>, Args&&... args) {
+    return f2<LArgs const&...>(args...);
+}
+
+int main() {
+    f1(list<>{}, 42);
+}

libcxx/trunk/test/support/test_workarounds.h

 
 #if defined(TEST_COMPILER_EDG)
 # define TEST_WORKAROUND_EDG_EXPLICIT_CONSTEXPR
 #endif
 
 #if defined(TEST_COMPILER_C1XX)
 # define TEST_WORKAROUND_C1XX_BROKEN_NULLPTR_CONVERSION_OPERATOR
 # define TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
+# define TEST_WORKAROUND_C1XX_EMPTY_PARAMETER_PACK_EXPANSION
 # ifndef _MSC_EXTENSIONS
 #  define TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
 # endif
 #endif
 
 #endif // SUPPORT_TEST_WORKAROUNDS_H

libcxx/trunk/test/support/uses_alloc_types.hpp

 #ifndef USES_ALLOC_TYPES_HPP
 #define USES_ALLOC_TYPES_HPP
 
 # include <memory>
 # include <cassert>
 #include <cstdlib>
 
 #include "test_macros.h"
+#include "test_workarounds.h"
 #include "type_id.h"
 
 // There are two forms of uses-allocator construction:
 //   (1) UA_AllocArg: 'T(allocator_arg_t, Alloc const&, Args&&...)'
 //   (2) UA_AllocLast: 'T(Args&&..., Alloc const&)'
 // 'UA_None' represents non-uses allocator construction.
 enum class UsesAllocatorType {
   UA_None = 0,
private:
     }
 
     template <class ...LArgs>
     static CtorAlloc getAllocatorFromPackImp(
         typename detail::Identity<LArgs>::type..., CtorAlloc const& alloc) {
         return alloc;
     }
 
+#ifdef TEST_WORKAROUND_C1XX_EMPTY_PARAMETER_PACK_EXPANSION
+    template <class ...LArgs>
+    static CtorAlloc getAllocatorFromPackImp(CtorAlloc const& alloc) {
+        return alloc;
+    }
+#endif
+
     bool has_alloc() const { return alloc_store.get_allocator() != nullptr; }
     const CtorAlloc *get_alloc() const { return alloc_store.get_allocator(); }
 public:
     const TypeID* args_id;
     UsesAllocatorType constructor_called = UA_None;
     UsesAllocatorTestBaseStorage<CtorAlloc> alloc_store;
 };