2 files changed, 20 insertions, 27 deletions
diff --git a/dev/kernel/NeKit/ErrorOr.h b/dev/kernel/NeKit/ErrorOr.h
index d7751b7e..b653e0ee 100644
--- a/dev/kernel/NeKit/ErrorOr.h
+++ b/dev/kernel/NeKit/ErrorOr.h
@@ -18,13 +18,13 @@ using ErrorT = UInt;
 template <typename T>
 class ErrorOr final {
  public:
-  ErrorOr()  = default;
-  ~ErrorOr() = default;
+  explicit ErrorOr() = default;
+  ~ErrorOr()         = default;
 
  public:
-  explicit ErrorOr(Int32 err) : mId(err) {}
+  explicit ErrorOr(Int32 err) : mRef((T*) RTL_ALLOCA(sizeof(T))), mId(err) {}
 
-  explicit ErrorOr(nullPtr Null) {}
+  explicit ErrorOr(nullPtr) {}
 
   explicit ErrorOr(T* Class) : mRef(Class) {}
 
@@ -48,7 +48,7 @@ class ErrorOr final {
 
  private:
   Ref<T> mRef;
-  UInt32 mId{0};
+  Int32  mId{0};
 };
 
 using ErrorOrAny = ErrorOr<voidPtr>;
diff --git a/dev/kernel/NeKit/Ref.h b/dev/kernel/NeKit/Ref.h
index 9920aa6f..4d343bc5 100644
--- a/dev/kernel/NeKit/Ref.h
+++ b/dev/kernel/NeKit/Ref.h
@@ -8,6 +8,7 @@
 #ifndef _NEWKIT_REF_H_
 #define _NEWKIT_REF_H_
 
+#include <CompilerKit/CompilerKit.h>
 #include <KernelKit/HeapMgr.h>
 #include <NeKit/Defines.h>
 #include <NeKit/KernelPanic.h>
@@ -16,41 +17,33 @@ namespace Kernel {
 template <typename T>
 class Ref final {
  public:
-  Ref() = default;
-
-  ~Ref() {
-    if (mm_is_valid_ptr(fClass)) delete fClass;
-  }
+  explicit Ref() = default;
+  ~Ref()         = default;
 
  public:
-  Ref(T* cls) : fClass(cls) {}
-
-  Ref(T cls) : fClass(nullptr) { fClass = &cls; }
+  Ref(T* cls) : fClass(*cls) {}
+  Ref(T cls) : fClass(cls) {}
 
   Ref& operator=(T ref) {
-    fClass = &ref;
+    fClass = ref;
     return *this;
   }
 
+  NE_COPY_DEFAULT(Ref);
+
  public:
-  T operator->() const {
-    MUST_PASS(*fClass);
-    return *fClass;
-  }
+  T operator->() const { return fClass; }
 
-  T& Leak() noexcept { return *fClass; }
+  T& Leak() noexcept { return fClass; }
 
-  T& TryLeak() const noexcept {
-    MUST_PASS(*fClass);
-    return *fClass;
-  }
+  T& TryLeak() const noexcept { return fClass; }
 
-  T operator*() { return *fClass; }
+  T operator*() { return fClass; }
 
-  operator bool() noexcept { return fClass; }
+  operator bool() noexcept { return true; }
 
  private:
-  T* fClass{nullptr};
+  T fClass;
 };
 
 template <typename T>
@@ -70,7 +63,7 @@ class NonNullRef final {
   NonNullRef(const NonNullRef<T>& ref)            = default;
 
  private:
-  Ref<T> fRef{nullptr};
+  Ref<T> fRef{};
 };
 }  // namespace Kernel