From 18b98f8c2893d2bd5d57ad5a4b8735c85b1d5d46 Mon Sep 17 00:00:00 2001
From: Idan Horowitz <idan.horowitz@gmail.com>
Date: Thu, 3 Feb 2022 17:19:53 +0200
Subject: AK: Convert the try_make<T> factory function to use ErrorOr

This allows more ergonomic memory allocation failure related error
checking using the TRY macro.
---
 AK/OwnPtr.h                    | 8 ++++----
 Documentation/SmartPointers.md | 7 ++++---
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/AK/OwnPtr.h b/AK/OwnPtr.h
index 4210bdf853..1eb888583c 100644
--- a/AK/OwnPtr.h
+++ b/AK/OwnPtr.h
@@ -215,17 +215,17 @@ inline ErrorOr<NonnullOwnPtr<T>> adopt_nonnull_own_or_enomem(T* object)
 }
 
 template<typename T, class... Args>
-requires(IsConstructible<T, Args...>) inline OwnPtr<T> try_make(Args&&... args)
+requires(IsConstructible<T, Args...>) inline ErrorOr<NonnullOwnPtr<T>> try_make(Args&&... args)
 {
-    return adopt_own_if_nonnull(new (nothrow) T(forward<Args>(args)...));
+    return adopt_nonnull_own_or_enomem(new (nothrow) T(forward<Args>(args)...));
 }
 
 // FIXME: Remove once P0960R3 is available in Clang.
 template<typename T, class... Args>
-inline OwnPtr<T> try_make(Args&&... args)
+inline ErrorOr<NonnullOwnPtr<T>> try_make(Args&&... args)
 
 {
-    return adopt_own_if_nonnull(new (nothrow) T { forward<Args>(args)... });
+    return adopt_nonnull_own_or_enomem(new (nothrow) T { forward<Args>(args)... });
 }
 
 template<typename T>
diff --git a/Documentation/SmartPointers.md b/Documentation/SmartPointers.md
index 9d63c2f335..b9d617b6a0 100644
--- a/Documentation/SmartPointers.md
+++ b/Documentation/SmartPointers.md
@@ -33,13 +33,14 @@ There is a `make<T>()` helper that constructs a new object and returns it wrappe
 }
 ```
 
-The `try_make<T>()` helper attempts to construct a new object wrapped in an `OwnPtr`. All arguments passed to it are forwarded to `T`'s constructor. In case of allocation failure, a null pointer is returned. This allows the calling code to handle allocation failure as it wishes.
+The `try_make<T>()` helper attempts to construct a new object wrapped in an `ErrorOr<NonnullOwnPtr<T>>`. All arguments passed to it are forwarded to `T`'s constructor. In case of allocation failure, an ENOMEM error is returned. This allows the calling code to handle allocation failure as it wishes.
 
 ```cpp
-OwnPtr<Foo> my_object = try_make<Foo>();
-if (!my_object) {
+auto my_object_or_error = try_make<Foo>();
+if (my_object_or_error.is_error()) {
     // handle allocation failure...
 }
+auto my_object = my_object_or_error.release_value();
 my_object->do_stuff();
 ```
 
-- 
cgit v1.2.3