[libcxx][test] MaybePOCCAAllocator should meet the Cpp17Allocator requirements

[CaseyCarter]

Summary

Implement rebind, the rebinding constructor, and rebind-compatible comparison operators.

[• Quuxplusone]

LGTM as long as the answers to all my questions are "no, what I have written here is correct." ;)

libcxx/test/support/allocators.h

199–202

Isn't there allocator_traits magic that does this for all templates automatically? or is that only in pointer_traits?

210

If CI is happy with this, then OK, but I suspect that whatever is happening with copy_assigned_into_ is not well-thought-out and works only by accident, wherever it's being used/tested.

233–235

I kneejerk want to leave this operator== alone and rely on the implicit converting ctor you just added... but would that make allocT == allocU ambiguous because the compiler doesn't know which operand to convert?

[CaseyCarter]

libcxx/test/support/allocators.h

199–202

The magic only works when the allocator is a specialization of a template with at least one type parameter and no non-type template parameters. ([allocator.traits.types]/11)

210

I think I just had the constructor copy what the == examines for head-in-the-sand conformance, but I suspect the result is tests that always pass. I'll investigate.

212

Unnecessary empty line.

233–235

I think that would be ambiguous, but I don't claim to be able to reason about operator rewrites in the presence of implicit conversions. I'll investigate.

[CaseyCarter]

Address review comments.

[CaseyCarter]

libcxx/test/support/allocators.h

210

Fixed.

233–235

At least two compilers agree with us that it would be ambigous.

libcxx/test/support/allocators.h

 {
     return !(x == y);
 }
 
 template <class T, bool POCCAValue>
 class MaybePOCCAAllocator {
     int id_ = 0;
     bool* copy_assigned_into_ = nullptr;
+
+    template<class, bool> friend class MaybePOCCAAllocator;
+
 public:
     typedef std::integral_constant<bool, POCCAValue> propagate_on_container_copy_assignment;
     typedef T value_type;
 
+    template <class U>
+    struct rebind {
+        typedef MaybePOCCAAllocator<U, POCCAValue> other;
+    };
+
     MaybePOCCAAllocator() = default;
     MaybePOCCAAllocator(int id, bool* copy_assigned_into)
         : id_(id), copy_assigned_into_(copy_assigned_into) {}
 
+    template <class U>
+    MaybePOCCAAllocator(const MaybePOCCAAllocator<U, POCCAValue>& that)
+        : id_(that.id_), copy_assigned_into_(that.copy_assigned_into_) {}
+
     MaybePOCCAAllocator(const MaybePOCCAAllocator&) = default;
     MaybePOCCAAllocator& operator=(const MaybePOCCAAllocator& a)
     {
         id_ = a.id();
         if (copy_assigned_into_)
             *copy_assigned_into_ = true;
         return *this;
     }
 
     T* allocate(std::size_t n)
     {
         return static_cast<T*>(::operator new(n * sizeof(T)));
     }
 
     void deallocate(T* ptr, std::size_t)
     {
         ::operator delete(ptr);
     }
 
     int id() const { return id_; }
 
-    friend bool operator==(const MaybePOCCAAllocator& lhs, const MaybePOCCAAllocator& rhs)
+    template <class U>
+    friend bool operator==(const MaybePOCCAAllocator& lhs, const MaybePOCCAAllocator<U, POCCAValue>& rhs)
     {
         return lhs.id() == rhs.id();
     }
 
-    friend bool operator!=(const MaybePOCCAAllocator& lhs, const MaybePOCCAAllocator& rhs)
+    template <class U>
+    friend bool operator!=(const MaybePOCCAAllocator& lhs, const MaybePOCCAAllocator<U, POCCAValue>& rhs)
     {
         return !(lhs == rhs);
     }
 };
 
 template <class T>
 using POCCAAllocator = MaybePOCCAAllocator<T, /*POCCAValue = */true>;
 template <class T>
 using NonPOCCAAllocator = MaybePOCCAAllocator<T, /*POCCAValue = */false>;
 
 #endif // TEST_STD_VER >= 11
 
 #endif // ALLOCATORS_H