AK: Add NonnullOwnPtr.

This is just like OwnPtr (also single-owner), except it cannot be null.

NonnullOwnPtr is perfect as the return type of functions that never need to
return nullptr.

It's also useful as an argument type to encode the fact that the argument
must not be nullptr.

The make<Foo>() helper is changed to return NonnullOwnPtr<Foo>.

Note: You can move() out of a NonnullOwnPtr, and after that the object is
in an invalid state. Internally it will be a nullptr at this point, so we'll
still catch misuse, but the only thing that should be done in this state
is running the destructor. I've used consumable annotations to generate some
warnings when using a NonnullOwnPtr after moving from it, but these only
work when compiling with clang, so be aware of that.

AK/NonnullOwnPtr.h

@@ -0,0 +1,157 @@
+#pragma once
+
+#include <AK/Assertions.h>
+#include <AK/LogStream.h>
+#include <AK/StdLibExtras.h>
+#include <AK/Traits.h>
+#include <AK/Types.h>
+
+namespace AK {
+
+template<typename T>
+class RefPtr;
+template<typename T>
+class NonnullRefPtr;
+template<typename T>
+class WeakPtr;
+
+template<typename T>
+class CONSUMABLE(unconsumed) NonnullOwnPtr {
+public:
+    enum AdoptTag { Adopt };
+
+    RETURN_TYPESTATE(unconsumed)
+    NonnullOwnPtr(AdoptTag, T& ptr)
+        : m_ptr(&ptr)
+    {
+    }
+    RETURN_TYPESTATE(unconsumed)
+    NonnullOwnPtr(NonnullOwnPtr&& other)
+        : m_ptr(other.leak_ptr())
+    {
+        ASSERT(m_ptr);
+    }
+    template<typename U>
+    RETURN_TYPESTATE(unconsumed)
+    NonnullOwnPtr(NonnullOwnPtr<U>&& other)
+        : m_ptr(static_cast<T*>(other.leak_ptr()))
+    {
+        ASSERT(m_ptr);
+    }
+    ~NonnullOwnPtr()
+    {
+        clear();
+#ifdef SANITIZE_PTRS
+        if constexpr (sizeof(T*) == 8)
+            m_ptr = (T*)(0xe3e3e3e3e3e3e3e3);
+        else
+            m_ptr = (T*)(0xe3e3e3e3);
+#endif
+    }
+
+    NonnullOwnPtr(const NonnullOwnPtr&) = delete;
+    template<typename U>
+    NonnullOwnPtr(const NonnullOwnPtr<U>&) = delete;
+    NonnullOwnPtr& operator=(const NonnullOwnPtr&) = delete;
+    template<typename U>
+    NonnullOwnPtr& operator=(const NonnullOwnPtr<U>&) = delete;
+
+    template<typename U>
+    NonnullOwnPtr(const RefPtr<U>&) = delete;
+    template<typename U>
+    NonnullOwnPtr(const NonnullRefPtr<U>&) = delete;
+    template<typename U>
+    NonnullOwnPtr(const WeakPtr<U>&) = delete;
+    template<typename U>
+    NonnullOwnPtr& operator=(const RefPtr<U>&) = delete;
+    template<typename U>
+    NonnullOwnPtr& operator=(const NonnullRefPtr<U>&) = delete;
+    template<typename U>
+    NonnullOwnPtr& operator=(const WeakPtr<U>&) = delete;
+
+    RETURN_TYPESTATE(unconsumed)
+    NonnullOwnPtr& operator=(NonnullOwnPtr&& other)
+    {
+        if (this != &other) {
+            delete m_ptr;
+            m_ptr = other.leak_ptr();
+            ASSERT(m_ptr);
+        }
+        return *this;
+    }
+
+    template<typename U>
+    RETURN_TYPESTATE(unconsumed)
+    NonnullOwnPtr& operator=(NonnullOwnPtr<U>&& other)
+    {
+        if (this != static_cast<void*>(&other)) {
+            delete m_ptr;
+            m_ptr = other.leak_ptr();
+            ASSERT(m_ptr);
+        }
+        return *this;
+    }
+
+    CALLABLE_WHEN(unconsumed)
+    SET_TYPESTATE(consumed)
+    T* leak_ptr()
+    {
+        return exchange(m_ptr, nullptr);
+    }
+
+    CALLABLE_WHEN(unconsumed)
+    T* ptr() { return m_ptr; }
+    CALLABLE_WHEN(unconsumed)
+    const T* ptr() const { return m_ptr; }
+
+    CALLABLE_WHEN(unconsumed)
+    T* operator->() { return m_ptr; }
+    CALLABLE_WHEN(unconsumed)
+    const T* operator->() const { return m_ptr; }
+
+    CALLABLE_WHEN(unconsumed)
+    T& operator*() { return *m_ptr; }
+    CALLABLE_WHEN(unconsumed)
+    const T& operator*() const { return *m_ptr; }
+
+    CALLABLE_WHEN(unconsumed)
+    operator const T*() const { return m_ptr; }
+    CALLABLE_WHEN(unconsumed)
+    operator T*() { return m_ptr; }
+
+private:
+    void clear()
+    {
+        if (!m_ptr)
+            return;
+        delete m_ptr;
+        m_ptr = nullptr;
+    }
+
+    T* m_ptr = nullptr;
+};
+
+template<class T, class... Args>
+inline NonnullOwnPtr<T>
+make(Args&&... args)
+{
+    return NonnullOwnPtr<T>(NonnullOwnPtr<T>::Adopt, *new T(forward<Args>(args)...));
+}
+
+template<typename T>
+struct Traits<NonnullOwnPtr<T>> : public GenericTraits<NonnullOwnPtr<T>> {
+    static unsigned hash(const NonnullOwnPtr<T>& p) { return (unsigned)p.ptr(); }
+    static void dump(const NonnullOwnPtr<T>& p) { kprintf("%p", p.ptr()); }
+    static bool equals(const NonnullOwnPtr<T>& a, const NonnullOwnPtr<T>& b) { return a.ptr() == b.ptr(); }
+};
+
+template<typename T>
+inline const LogStream& operator<<(const LogStream& stream, const NonnullOwnPtr<T>& value)
+{
+    return stream << value.ptr();
+}
+
+}
+
+using AK::make;
+using AK::NonnullOwnPtr;

AK/OwnPtr.h

@@ -1,19 +1,9 @@
 #pragma once
 
-#include <AK/LogStream.h>
-#include <AK/StdLibExtras.h>
-#include <AK/Traits.h>
-#include <AK/Types.h>
+#include <AK/NonnullOwnPtr.h>
 
 namespace AK {
 
-template<typename T>
-class RefPtr;
-template<typename T>
-class NonnullRefPtr;
-template<typename T>
-class WeakPtr;
-
 template<typename T>
 class OwnPtr {
 public:
@@ -26,6 +16,12 @@ public:
         : m_ptr(other.leak_ptr())
     {
     }
+
+    template<typename U>
+    OwnPtr(NonnullOwnPtr<U>&& other)
+        : m_ptr(static_cast<T*>(other.leak_ptr()))
+    {
+    }
     template<typename U>
     OwnPtr(OwnPtr<U>&& other)
         : m_ptr(static_cast<T*>(other.leak_ptr()))
@@ -43,6 +39,13 @@ public:
 #endif
     }
 
+    OwnPtr(const OwnPtr&) = delete;
+    template<typename U>
+    OwnPtr(const OwnPtr<U>&) = delete;
+    OwnPtr& operator=(const OwnPtr&) = delete;
+    template<typename U>
+    OwnPtr& operator=(const OwnPtr<U>&) = delete;
+
     template<typename U>
     OwnPtr(const RefPtr<U>&) = delete;
     template<typename U>
@@ -75,6 +78,15 @@ public:
         return *this;
     }
 
+    template<typename U>
+    OwnPtr& operator=(NonnullOwnPtr<U>&& other)
+    {
+        ASSERT(m_ptr != other.ptr());
+        delete m_ptr;
+        m_ptr = other.leak_ptr();
+        return *this;
+    }
+
     OwnPtr& operator=(T* ptr)
     {
         if (m_ptr != ptr)
@@ -99,9 +111,9 @@ public:
 
     T* leak_ptr()
     {
-        T* leakedPtr = m_ptr;
+        T* leaked_ptr = m_ptr;
         m_ptr = nullptr;
-        return leakedPtr;
+        return leaked_ptr;
     }
 
     T* ptr() { return m_ptr; }
@@ -122,13 +134,6 @@ private:
     T* m_ptr = nullptr;
 };
 
-template<class T, class... Args>
-inline OwnPtr<T>
-make(Args&&... args)
-{
-    return OwnPtr<T>(new T(AK::forward<Args>(args)...));
-}
-
 template<typename T>
 struct Traits<OwnPtr<T>> : public GenericTraits<OwnPtr<T>> {
     static unsigned hash(const OwnPtr<T>& p) { return (unsigned)p.ptr(); }
@@ -144,5 +149,4 @@ inline const LogStream& operator<<(const LogStream& stream, const OwnPtr<T>& val
 
 }
 
-using AK::make;
 using AK::OwnPtr;