core: backport some ResultCode updates (#6645)

Co-authored-by: Lioncash <mathew1800@gmail.com>
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>

src/core/hle/kernel/client_port.cpp

@@ -40,7 +40,7 @@ ResultVal<std::shared_ptr<ClientSession>> ClientPort::Connect() {
     // Wake the threads waiting on the ServerPort
     server_port->WakeupAllWaitingThreads();
 
-    return MakeResult(client);
+    return client;
 }
 
 void ClientPort::ConnectionClosed() {

src/core/hle/kernel/handle_table.cpp

@@ -49,7 +49,7 @@ ResultVal<Handle> HandleTable::Create(std::shared_ptr<Object> obj) {
     objects[slot] = std::move(obj);
 
     Handle handle = generation | (slot << 15);
-    return MakeResult<Handle>(handle);
+    return handle;
 }
 
 ResultVal<Handle> HandleTable::Duplicate(Handle handle) {

src/core/hle/kernel/process.cpp

@@ -271,7 +271,7 @@ ResultVal<VAddr> Process::HeapAllocate(VAddr target, u32 size, VMAPermission per
     memory_used += size;
     resource_limit->current_commit += size;
 
-    return MakeResult<VAddr>(target);
+    return target;
 }
 
 ResultCode Process::HeapFree(VAddr target, u32 size) {
@@ -344,7 +344,7 @@ ResultVal<VAddr> Process::LinearAllocate(VAddr target, u32 size, VMAPermission p
     resource_limit->current_commit += size;
 
     LOG_DEBUG(Kernel, "Allocated at target={:08X}", target);
-    return MakeResult<VAddr>(target);
+    return target;
 }
 
 ResultCode Process::LinearFree(VAddr target, u32 size) {

src/core/hle/kernel/semaphore.cpp

@@ -31,7 +31,7 @@ ResultVal<std::shared_ptr<Semaphore>> KernelSystem::CreateSemaphore(s32 initial_
     semaphore->available_count = initial_count;
     semaphore->name = std::move(name);
 
-    return MakeResult<std::shared_ptr<Semaphore>>(std::move(semaphore));
+    return semaphore;
 }
 
 bool Semaphore::ShouldWait(const Thread* thread) const {
@@ -53,7 +53,7 @@ ResultVal<s32> Semaphore::Release(s32 release_count) {
 
     WakeupAllWaitingThreads();
 
-    return MakeResult<s32>(previous_count);
+    return previous_count;
 }
 
 } // namespace Kernel

src/core/hle/kernel/server_port.cpp

@@ -31,7 +31,7 @@ ResultVal<std::shared_ptr<ServerSession>> ServerPort::Accept() {
 
     auto session = std::move(pending_sessions.back());
     pending_sessions.pop_back();
-    return MakeResult(std::move(session));
+    return session;
 }
 
 bool ServerPort::ShouldWait(const Thread* thread) const {

src/core/hle/kernel/server_session.cpp

@@ -52,7 +52,7 @@ ResultVal<std::shared_ptr<ServerSession>> ServerSession::Create(KernelSystem& ke
     server_session->name = std::move(name);
     server_session->parent = nullptr;
 
-    return MakeResult(std::move(server_session));
+    return server_session;
 }
 
 bool ServerSession::ShouldWait(const Thread* thread) const {

src/core/hle/kernel/shared_memory.cpp

@@ -69,7 +69,7 @@ ResultVal<std::shared_ptr<SharedMemory>> KernelSystem::CreateSharedMemory(
     }
 
     shared_memory->base_address = address;
-    return MakeResult(shared_memory);
+    return shared_memory;
 }
 
 std::shared_ptr<SharedMemory> KernelSystem::CreateSharedMemoryForApplet(

src/core/hle/kernel/svc.cpp

@@ -674,7 +674,7 @@ ResultCode SVC::OpenProcess(Handle* out_handle, u32 process_id) {
         return ResultCode(24, ErrorModule::OS, ErrorSummary::WrongArgument, ErrorLevel::Permanent);
     }
     auto result_handle = kernel.GetCurrentProcess()->handle_table.Create(process);
-    if (result_handle.empty()) {
+    if (!result_handle) {
         return result_handle.Code();
     }
     *out_handle = result_handle.Unwrap();
@@ -699,7 +699,7 @@ ResultCode SVC::OpenThread(Handle* out_handle, Handle process_handle, u32 thread
         for (auto& thread : thread_list) {
             if (thread->owner_process.lock() == process && thread.get()->thread_id == thread_id) {
                 auto result_handle = kernel.GetCurrentProcess()->handle_table.Create(thread);
-                if (result_handle.empty()) {
+                if (!result_handle) {
                     return result_handle.Code();
                 }
                 *out_handle = result_handle.Unwrap();

src/core/hle/kernel/thread.cpp

@@ -423,7 +423,7 @@ ResultVal<std::shared_ptr<Thread>> KernelSystem::CreateThread(
     thread_managers[processor_id]->ready_queue.push_back(thread->current_priority, thread.get());
     thread->status = ThreadStatus::Ready;
 
-    return MakeResult<std::shared_ptr<Thread>>(std::move(thread));
+    return thread;
 }
 
 void Thread::SetPriority(u32 priority) {

src/core/hle/kernel/vm_manager.cpp

@@ -96,7 +96,7 @@ ResultVal<VAddr> VMManager::MapBackingMemoryToBase(VAddr base, u32 region_size,
     if (result.Failed())
         return result.Code();
 
-    return MakeResult<VAddr>(target);
+    return target;
 }
 
 ResultVal<VMManager::VMAHandle> VMManager::MapBackingMemory(VAddr target, MemoryRef memory,
@@ -115,7 +115,7 @@ ResultVal<VMManager::VMAHandle> VMManager::MapBackingMemory(VAddr target, Memory
     final_vma.backing_memory = memory;
     UpdatePageTableForVMA(final_vma);
 
-    return MakeResult<VMAHandle>(MergeAdjacent(vma_handle));
+    return MergeAdjacent(vma_handle);
 }
 
 ResultVal<VMManager::VMAHandle> VMManager::MapMMIO(VAddr target, PAddr paddr, u32 size,
@@ -135,7 +135,7 @@ ResultVal<VMManager::VMAHandle> VMManager::MapMMIO(VAddr target, PAddr paddr, u3
     final_vma.mmio_handler = mmio_handler;
     UpdatePageTableForVMA(final_vma);
 
-    return MakeResult<VMAHandle>(MergeAdjacent(vma_handle));
+    return MergeAdjacent(vma_handle);
 }
 
 ResultCode VMManager::ChangeMemoryState(VAddr target, u32 size, MemoryState expected_state,
@@ -294,7 +294,7 @@ ResultVal<VMManager::VMAIter> VMManager::CarveVMA(VAddr base, u32 size) {
         vma_handle = SplitVMA(vma_handle, start_in_vma);
     }
 
-    return MakeResult<VMAIter>(vma_handle);
+    return vma_handle;
 }
 
 ResultVal<VMManager::VMAIter> VMManager::CarveVMARange(VAddr target, u32 size) {
@@ -322,7 +322,7 @@ ResultVal<VMManager::VMAIter> VMManager::CarveVMARange(VAddr target, u32 size) {
         end_vma = SplitVMA(end_vma, target_end - end_vma->second.base);
     }
 
-    return MakeResult<VMAIter>(begin_vma);
+    return begin_vma;
 }
 
 VMManager::VMAIter VMManager::SplitVMA(VMAIter vma_handle, u32 offset_in_vma) {
@@ -409,6 +409,6 @@ ResultVal<std::vector<std::pair<MemoryRef, u32>>> VMManager::GetBackingBlocksFor
 
         interval_target += interval_size;
     }
-    return MakeResult(backing_blocks);
+    return backing_blocks;
 }
 } // namespace Kernel