[libc++] Implement std::experimental::observer_ptr

[ldionne]

Summary

This patch adds std::experimental::observer_ptr (n4282) and also
fixes LWG2516.

[zoecarver]

• fix overload resolution

[EricWF]

Questions:

Is it okay to use constexpr and noexcept or should I use the macros?

Yes. For entirely new features, all of C++11 and C++14 are on the table now.
But for additions or changes to existing components, use the same style as the existing code.

Should this use the experimental namespace? The paper made it seem like std was sufficient.

We implement a C++ standard, what namespace does it say?

I think there is something else I need to do when adding a header.

There's a set up steps here:
https://github.com/llvm-mirror/libcxx/blob/master/NOTES.TXT#L19

But generally it looked good.

The greater than operator seemed wrong.

Say more?

[zoecarver]

• new header things

Questions:

Is it okay to use constexpr and noexcept or should I use the macros?

Yes. For entirely new features, all of C++11 and C++14 are on the table now.
But for additions or changes to existing components, use the same style as the existing code.

Good to know. Thanks.

I think there is something else I need to do when adding a header.

There's a set up steps here:
https://github.com/llvm-mirror/libcxx/blob/master/NOTES.TXT#L19

But generally it looked good.

Done.

The greater than operator seemed wrong.

Say more?

The standard says that the greater than and less than operators should have the same functionality. This seems wrong to me, but I might be missing something.

[EricWF]

The implementation looks great!

I've added some inline comments, but I think the biggest remaining issue is the lack of constexpr tests. If a function is declared constexpr, we should have a test for it.

Let me know if you have any questions.

include/experimental/memory

50

The first include should always be either <__config>, or when in experimental, <experimental/__config>.

61

This header should ifdef everything out when _LIBCPP_STD_VER <= 14. I would put these guards just inside the namespace declaration.

63

Yes. You *cannot* add additional symbols to namespace std

68

These should be reserved names if they're not part of the spec.

82

Use the new _EnableIf trait instead of enable_if_t.

96

Why is explicit commented out`?

112

I think we probably want to noexcept each of these free functions.

test/libcxx/experimental/memory/memory.observer.ptr/version.pass.cpp

12

Wrong header?

test/std/experimental/memory/memory.observer.ptr/hash.pass.cpp

34

Copy paste error?

[xbolva00]

include/experimental/memory

169

Standard says "Returns: p2 < p1.".

So in your case, "b < a" ?

[zoecarver]

I am so glad you like it :) thanks for the review @EricWF! I will add constexpr tests and fix the comments.

include/experimental/memory

169

How did I miss this... I read over it so many times. Anyway, thank you @xbolva00.

[zoecarver]

include/experimental/memory

82

Will do, but any specific reason for this?

96

I would expect is_convertible< observer_ptr<T>, T*> to be true, but when this is explicit that statement is not true.

[zoecarver]

include/experimental/memory

50

Good to know, thanks.

63

You're right. That is what the standard says. I was confused by the paper.

68

Based on 2516 it was unclear to me whether these should still exist or should be mangled.

[zoecarver]

• updated based on your comments
• added a few constexpr tests

My main question with adding constexpr is in swap. I am not sure how to make a swap function that is constexpr.

[zoecarver]

• add more constexpr tests

[zoecarver]

Ping.

[zoecarver]

Friendly ping.

[ldionne]

[Github PR transition cleanup]

Commandeering to pick up.

[ldionne]

Rebase, fix a few things, clang-format.

[ldionne]

Rebase on top of latest spec, revisit tests.

[ldionne]

Add missing _LIBCPP_HIDE_FROM_ABI and fix transitive includes.

[ldionne]

Add missing include to test.

[ldionne]

Fix formatting.

[ldionne]

Fix C++17 test.

include/CMakeLists.txt

set(files
   experimental/coroutine
   experimental/deque
   experimental/filesystem
   experimental/forward_list
   experimental/functional
   experimental/iterator
   experimental/list
   experimental/map
+  experimental/memory
   experimental/memory_resource
   experimental/propagate_const
   experimental/regex
   experimental/set
   experimental/simd
   experimental/string
   experimental/type_traits
   experimental/unordered_map

include/experimental/memory

+// -*- C++ -*-
+//===-------------------------- algorithm ---------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL_MEMORY
+#define _LIBCPP_EXPERIMENTAL_MEMORY
+
+/*
+namespace std {
+template <class W> class observer_ptr {
+public:
+    // publish our template parameter and variations thereof
+    using element_type = W;
+    using pointer = add_pointer_t<W>; // exposition-only
+    using reference = add_lvalue_reference_t<W>; // exposition-only
+
+    // default c’tor
+    constexpr observer_ptr() noexcept;
+
+    // pointer-accepting c’tors
+    constexpr observer_ptr(nullptr_t) noexcept;
+    constexpr explicit observer_ptr(pointer) noexcept;
+
+    // copying c’tors (in addition to compiler-generated copy c’tor)
+    template <class W2> constexpr observer_ptr(observer_ptr<W2>) noexcept;
+
+    // observers
+    constexpr pointer get() const noexcept;
+    constexpr reference operator*() const;
+    constexpr pointer operator->() const noexcept;
+    constexpr explicit operator bool() const noexcept;
+
+    // conversions
+    constexpr explicit operator pointer() const noexcept;
+
+    // modifiers
+    constexpr pointer release() noexcept;
+    constexpr void reset(pointer = nullptr) noexcept;
+    constexpr void swap(observer_ptr&) noexcept;
+};
+}
+*/
+
+#include <experimental/__config>
+#include <type_traits>
+#include <functional>
+
+#include <__debug>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS
+
+#if _LIBCPP_STD_VER > 14
+
+template<class _Wp>
+class observer_ptr
+{
+    typedef add_pointer_t<_Wp>          pointer;
+    typedef add_lvalue_reference_t<_Wp> reference;
+
+    pointer __ptr;
+
+public:
+    typedef _Wp                         element_type;
+
+    // constructors
+    constexpr observer_ptr() noexcept : __ptr(nullptr) { }
+    constexpr observer_ptr(nullptr_t) noexcept : __ptr(nullptr) { }
+    constexpr explicit observer_ptr(pointer __p) noexcept : __ptr(__p) { }
+
+    template<class _W2,
+             class = _EnableIf<is_convertible<_W2*, _Wp*>::value>>
+    constexpr observer_ptr(observer_ptr<_W2> __other) noexcept
+        : __ptr(__other.get()) { }
+
+    observer_ptr(observer_ptr const&) = default;
+    observer_ptr(observer_ptr&&) = default;
+
+    // observers
+    constexpr pointer get() const noexcept { return __ptr; }
+    constexpr reference operator*() const { return *__ptr; }
+    constexpr pointer operator->() const noexcept { return __ptr; }
+    constexpr explicit operator bool() const noexcept { return __ptr != nullptr; }
+
+    // conversions
+    constexpr operator pointer() const noexcept { return __ptr; }
+
+    // modifiers
+    constexpr void swap(observer_ptr& __other) noexcept { _VSTD::swap(__ptr, __other.__ptr); }
+    constexpr void reset(pointer __p = nullptr) { __ptr = __p; }
+    constexpr pointer release() noexcept
+    {
+        observer_ptr __p;
+        __p.swap(*this);
+        return __p.get();
+    }
+};
+
+// specializations
+
+template<class _Wp>
+void swap(observer_ptr<_Wp>& __a, observer_ptr<_Wp>& __b) noexcept
+{
+    __a.swap(__b);
+}
+
+template<class _Wp>
+observer_ptr<_Wp> make_observer(_Wp* __ptr) noexcept
+{
+    return observer_ptr<_Wp>{__ptr};
+}
+
+template<class _W1, class _W2>
+bool operator==(observer_ptr<_W1> __a, observer_ptr<_W2> __b)
+{
+    return __a.get() == __b.get();
+}
+
+template<class _W1, class _W2>
+bool operator!=(observer_ptr<_W1> __a, observer_ptr<_W2> __b)
+{
+    return !(__a == __b);
+}
+
+template<class _Wp>
+bool operator==(observer_ptr<_Wp> __p, nullptr_t)
+{
+    return !__p;
+}
+
+template<class _Wp>
+bool operator==(nullptr_t, observer_ptr<_Wp> __p)
+{
+    return !__p;
+}
+
+template<class _Wp>
+bool operator!=(observer_ptr<_Wp> __p, nullptr_t)
+{
+    return (bool)__p;
+}
+
+template<class _Wp>
+bool operator!=(nullptr_t, observer_ptr<_Wp> __p)
+{
+    return (bool)__p;
+}
+
+template<class _W1, class _W2>
+bool operator<(observer_ptr<_W1> __a, observer_ptr<_W2> __b)
+{
+    return _VSTD::less<typename _VSTD::common_type<_W1*, _W2*>::type>()(__a.get(), __b.get());
+}
+
+template<class _W1, class _W2>
+bool operator>(observer_ptr<_W1> __a, observer_ptr<_W2> __b)
+{
+    return __b < __a;
+}
+
+template<class _W1, class _W2>
+bool operator<=(observer_ptr<_W1> __a, observer_ptr<_W2> __b)
+{
+    return !(__a > __b);
+}
+
+template<class _W1, class _W2>
+bool operator>=(observer_ptr<_W1> __a, observer_ptr<_W2> __b)
+{
+    return !(__a < __b);
+}
+
+#endif // _LIBCPP_STD_VER > 14
+
+_LIBCPP_END_NAMESPACE_LFTS
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// hash
+
+#if _LIBCPP_STD_VER > 14
+template<class _Tp>
+struct hash<experimental::observer_ptr<_Tp>>
+{
+    typedef experimental::observer_ptr<_Tp>    argument_type;
+    typedef size_t                             result_type;
+
+    _LIBCPP_INLINE_VISIBILITY
+    result_type operator()(const argument_type& __ptr) const noexcept
+    {
+        return hash<_Tp*>()(__ptr.get());
+    }
+};
+#endif // _LIBCPP_STD_VER > 14
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif /* _LIBCPP_EXPERIMENTAL_MEMORY */

include/module.modulemap

module list {
       header "experimental/list"
       export *
     }
     module map {
       header "experimental/map"
       export *
     }
     module memory_resource {
+      header "experimental/memory"
+      export *
+    }
+    module memory_resource {
       header "experimental/memory_resource"
       export *
     }
     module propagate_const {
       header "experimental/propagate_const"
       export *
     }
     module regex {

test/libcxx/double_include.sh.cpp

 #endif
 #include <experimental/deque>
 #include <experimental/filesystem>
 #include <experimental/forward_list>
 #include <experimental/functional>
 #include <experimental/iterator>
 #include <experimental/list>
 #include <experimental/map>
+#include <experimental/memory>
 #include <experimental/memory_resource>
 #include <experimental/propagate_const>
 #include <experimental/regex>
 #include <experimental/simd>
 #include <experimental/set>
 #include <experimental/string>
 #include <experimental/type_traits>
 #include <experimental/unordered_map>

test/libcxx/experimental/memory/memory.observer.ptr/version.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/memory>
+
+#include <experimental/memory>
+
+#include "test_macros.h"
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main(int, char**)
+{
+
+  return 0;
+}

test/std/experimental/memory/memory.observer.ptr/conv.pass.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+template<class T>
+void test_convertibility()
+{
+    typedef std::experimental::observer_ptr<T> OP;
+    static_assert(std::is_convertible<OP, T*>::value, "");
+}
+
+struct Foo;
+
+struct Bar {};
+
+int main(int, char**)
+{
+    test_convertibility<void>();
+    test_convertibility<bool>();
+    test_convertibility<int>();
+    test_convertibility<Foo>();
+    test_convertibility<Bar>();
+
+    return 0;
+}
 No newline at end of file

test/std/experimental/memory/memory.observer.ptr/ctor.pass.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+template<class T>
+void custom_delete(T* ptr) { delete ptr; }
+void custom_delete(void* ptr) { delete (int*)ptr; }
+
+template<class T, class U>
+void assert_constructability()
+{
+    typedef std::experimental::observer_ptr<T> OP;
+    static_assert(std::is_nothrow_constructible<OP>::value, "");
+    static_assert(std::is_nothrow_constructible<OP, std::nullptr_t>::value, "");
+    static_assert(std::is_nothrow_constructible<OP, T*>::value, "");
+    static_assert(std::is_nothrow_constructible<OP, OP const&>::value, "");
+    static_assert(std::is_nothrow_constructible<OP, OP&&>::value, "");
+    static_assert(std::is_nothrow_constructible<OP, std::experimental::observer_ptr<U>>::value ==
+                  std::is_convertible<U*, T*>::value, "");
+}
+
+template<class T>
+void constrct_nullptr()
+{
+    {
+        std::experimental::observer_ptr<T> ptr;
+        assert(ptr.get() == nullptr);
+    }
+    {
+        std::experimental::observer_ptr<T> ptr(nullptr);
+        assert(ptr.get() == nullptr);
+    }
+}
+
+template<class T>
+void constrct_ptr(T* raw_ptr)
+{
+    std::experimental::observer_ptr<T> ptr(raw_ptr);
+    assert(ptr.get() == raw_ptr);
+    custom_delete(raw_ptr);
+}
+
+template<class T, class U>
+void constrct_other(U* raw_ptr)
+{
+    std::experimental::observer_ptr<U> uptr(raw_ptr);
+    std::experimental::observer_ptr<T> tptr(uptr);
+    assert(uptr.get() == raw_ptr);
+    assert(tptr.get() == raw_ptr);
+    custom_delete(raw_ptr);
+}
+
+template<class T>
+void test_copy_move(T* raw_ptr)
+{
+    std::experimental::observer_ptr<T> ptr_a(raw_ptr);
+    std::experimental::observer_ptr<T> ptr_b(ptr_a);
+    std::experimental::observer_ptr<T> ptr_c(std::move(ptr_a));
+    assert(ptr_b.get() == raw_ptr);
+    assert(ptr_c.get() == raw_ptr);
+    custom_delete(raw_ptr);
+}
+
+struct Foo;
+struct Bar
+{
+    Bar(int) {}
+};
+
+int main(int, char**)
+{
+    {
+        assert_constructability<void, void>();
+        assert_constructability<void, int>();
+        assert_constructability<void, Bar>();
+        assert_constructability<Foo,  void>();
+        assert_constructability<Foo,  int>();
+        assert_constructability<Foo,  Bar>();
+        assert_constructability<int,  void>();
+        assert_constructability<int,  int>();
+        assert_constructability<int,  Bar>();
+    }
+    {
+        constrct_nullptr<Foo>();
+        constrct_nullptr<Bar>();
+        constrct_nullptr<int>();
+        constrct_nullptr<void>();
+    }
+    {
+        constrct_ptr(new int);
+        constrct_ptr(new Bar(42));
+        constrct_ptr((void*)new int);
+    }
+    {
+        constrct_other<void>(new int);
+        constrct_other<void>(new Bar(42));
+
+        // overload resolution
+        typedef std::experimental::observer_ptr<int>  OP1;
+        typedef std::experimental::observer_ptr<Bar>  OP2;
+        typedef std::experimental::observer_ptr<char> OP3;
+        static_assert(!std::is_nothrow_constructible<OP1, OP2>::value, "");
+        static_assert(!std::is_nothrow_constructible<OP1, OP3>::value, "");
+    }
+    {
+        test_copy_move(new int);
+        test_copy_move((void*)new int);
+        test_copy_move(new Bar(42));
+    }
+
+    return 0;
+}
 No newline at end of file

test/std/experimental/memory/memory.observer.ptr/hash.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <cassert>
+
+#include "poisoned_hash_helper.hpp"
+#include "test_macros.h"
+
+struct A {};
+
+int main(int, char**)
+{
+    {
+        int* ptr = new int;
+        std::experimental::observer_ptr<int> p(ptr);
+        std::hash<std::experimental::observer_ptr<int>> f;
+        std::size_t h = f(p);
+        assert(h == std::hash<int*>()(ptr));
+    }
+    {
+        test_hash_enabled_for_type<std::experimental::observer_ptr<int>>();
+        test_hash_enabled_for_type<std::experimental::observer_ptr<A>>();
+    }
+
+    return 0;
+}

test/std/experimental/memory/memory.observer.ptr/mod/release.pass.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    {
+        std::experimental::observer_ptr<int> ptr;
+        assert(ptr.release() == nullptr);
+        assert(ptr.get() == nullptr);
+    }
+    {
+        int* raw_ptr = new int;
+        std::experimental::observer_ptr<int> ptr(raw_ptr);
+        assert(ptr.release() == raw_ptr);
+        assert(ptr.get() == nullptr);
+        delete raw_ptr;
+    }
+
+    return 0;
+}
 No newline at end of file

test/std/experimental/memory/memory.observer.ptr/mod/reset.pass.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    int* raw_ptr1 = new int;
+    int* raw_ptr2 = new int;
+
+    {
+        std::experimental::observer_ptr<int> ptr;
+        ptr.reset(raw_ptr1);
+        assert(ptr.get() == raw_ptr1);
+    }
+    {
+        std::experimental::observer_ptr<int> ptr(raw_ptr1);
+        ptr.reset(raw_ptr2);
+        assert(ptr.get() == raw_ptr2);
+    }
+
+    delete raw_ptr1;
+    delete raw_ptr2;
+
+    return 0;
+}
 No newline at end of file

test/std/experimental/memory/memory.observer.ptr/mod/swap.pass.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    int* raw_ptr1 = new int;
+    int* raw_ptr2 = new int;
+
+    {
+        std::experimental::observer_ptr<int> ptr1;
+        std::experimental::observer_ptr<int> ptr2;
+        ptr1.swap(ptr2);
+        assert(ptr1.get() == nullptr);
+        assert(ptr2.get() == nullptr);
+    }
+    {
+        std::experimental::observer_ptr<int> ptr1(raw_ptr1);
+        std::experimental::observer_ptr<int> ptr2;
+        ptr1.swap(ptr2);
+        assert(ptr1.get() == nullptr);
+        assert(ptr2.get() == raw_ptr1);
+    }
+    {
+        std::experimental::observer_ptr<int> ptr1;
+        std::experimental::observer_ptr<int> ptr2(raw_ptr2);
+        ptr1.swap(ptr2);
+        assert(ptr1.get() == raw_ptr2);
+        assert(ptr2.get() == nullptr);
+    }
+    {
+        std::experimental::observer_ptr<int> ptr1(raw_ptr1);
+        std::experimental::observer_ptr<int> ptr2(raw_ptr2);
+        ptr1.swap(ptr2);
+        assert(ptr1.get() == raw_ptr2);
+        assert(ptr2.get() == raw_ptr1);
+    }
+
+    delete raw_ptr1;
+    delete raw_ptr2;
+
+    return 0;
+}
 No newline at end of file

test/std/experimental/memory/memory.observer.ptr/obs.pass.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct Foo {
+    const int x;
+    constexpr Foo(const int x) : x(x) {}
+};
+
+int main(int, char**)
+{
+    static constexpr int x = 42;
+    constexpr const int* raw_ptr = &x;
+    {
+        constexpr std::experimental::observer_ptr<const int> ptr(raw_ptr);
+        static_assert(ptr.get() == raw_ptr);
+    }
+    {
+        constexpr std::experimental::observer_ptr<const int> ptr1;
+        const bool check1 = ptr1;
+        static_assert(check1 == false);
+
+        constexpr std::experimental::observer_ptr<const int> ptr2(raw_ptr);
+        const bool check2 = ptr2;
+        static_assert(check2 == true);
+    }
+    {
+        static constexpr Foo f = Foo(42);
+        constexpr const Foo* foo_ptr = &f;
+        constexpr std::experimental::observer_ptr<const Foo> ptr(foo_ptr);
+        static_assert(ptr->x == 42);
+        static_assert((*ptr).x == 42);
+
+    }
+
+    return 0;
+}
 No newline at end of file

test/std/experimental/memory/memory.observer.ptr/spec.pass.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    {
+        std::experimental::observer_ptr<int> ptr1(new int(42));
+        std::experimental::observer_ptr<int> ptr2(new int(101));
+        std::experimental::swap(ptr1, ptr2);
+
+        assert(*ptr1 == 101);
+        assert(*ptr2 == 42);
+
+        delete ptr1.get();
+        delete ptr2.get();
+    }
+    {
+        int* raw = new int;
+        std::experimental::observer_ptr<int> ptr = std::experimental::make_observer(raw);
+        assert(ptr.get() == raw);
+        delete raw;
+    }
+
+    std::experimental::observer_ptr<int> ptr1(new int);
+    std::experimental::observer_ptr<int> ptr2(new int);
+    std::experimental::observer_ptr<int> ptr3;
+    std::experimental::observer_ptr<void> vptr((void*)new int);
+    {
+        assert(ptr1 == ptr1);
+        assert(!(ptr1 == ptr2));
+    }
+    {
+        assert(ptr1 != ptr2);
+    }
+    {
+        assert(ptr3 == nullptr);
+        assert(nullptr == ptr3);
+        assert(!(ptr1 == nullptr));
+        assert(!(nullptr == ptr1));
+    }
+    {
+        assert(!(ptr3 != nullptr));
+        assert(!(nullptr != ptr3));
+        assert(ptr1 != nullptr);
+        assert(nullptr != ptr1);
+    }
+    {
+        assert((ptr1 < ptr1) == (ptr1.get() < ptr1.get()));
+        assert((ptr1 < vptr) == (ptr1.get() < vptr.get()));
+    }
+    {
+        assert((ptr1 > ptr1) == (ptr1.get() > ptr1.get()));
+        assert((ptr1 > vptr) == (ptr1.get() > vptr.get()));
+    }
+    {
+        assert((ptr1 <= ptr1) != (ptr1.get() > ptr1.get()));
+        assert((ptr1 <= vptr) != (ptr1.get() > vptr.get()));
+    }
+    {
+        assert((ptr1 >= ptr1) != (ptr1.get() < ptr1.get()));
+        assert((ptr1 >= vptr) != (ptr1.get() < vptr.get()));
+    }
+
+    delete ptr1.get();
+    delete ptr2.get();
+    delete (int*)vptr.get();
+
+    return 0;
+}