core: remove ResultVal type

src/core/file_sys/romfs_factory.cpp

@@ -35,7 +35,7 @@ void RomFSFactory::SetPackedUpdate(VirtualFile update_raw_file) {
     update_raw = std::move(update_raw_file);
 }
 
-ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_title_id) const {
+VirtualFile RomFSFactory::OpenCurrentProcess(u64 current_process_title_id) const {
     if (!updatable) {
         return file;
     }
@@ -45,12 +45,11 @@ ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_titl
     return patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw);
 }
 
-ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecordType type) const {
+VirtualFile RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecordType type) const {
     auto nca = content_provider.GetEntry(title_id, type);
 
     if (nca == nullptr) {
-        // TODO: Find the right error code to use here
-        return ResultUnknown;
+        return nullptr;
     }
 
     const PatchManager patch_manager{title_id, filesystem_controller, content_provider};
@@ -58,28 +57,20 @@ ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecor
     return patch_manager.PatchRomFS(nca->GetRomFS(), nca->GetBaseIVFCOffset(), type);
 }
 
-ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFSWithProgramIndex(
-    u64 title_id, u8 program_index, ContentRecordType type) const {
+VirtualFile RomFSFactory::OpenPatchedRomFSWithProgramIndex(u64 title_id, u8 program_index,
+                                                           ContentRecordType type) const {
     const auto res_title_id = GetBaseTitleIDWithProgramIndex(title_id, program_index);
 
     return OpenPatchedRomFS(res_title_id, type);
 }
 
-ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage,
-                                          ContentRecordType type) const {
+VirtualFile RomFSFactory::Open(u64 title_id, StorageId storage, ContentRecordType type) const {
     const std::shared_ptr<NCA> res = GetEntry(title_id, storage, type);
     if (res == nullptr) {
-        // TODO(DarkLordZach): Find the right error code to use here
-        return ResultUnknown;
+        return nullptr;
     }
 
-    const auto romfs = res->GetRomFS();
-    if (romfs == nullptr) {
-        // TODO(DarkLordZach): Find the right error code to use here
-        return ResultUnknown;
-    }
-
-    return romfs;
+    return res->GetRomFS();
 }
 
 std::shared_ptr<NCA> RomFSFactory::GetEntry(u64 title_id, StorageId storage,

src/core/file_sys/romfs_factory.h

@@ -41,13 +41,11 @@ public:
     ~RomFSFactory();
 
     void SetPackedUpdate(VirtualFile update_raw_file);
-    [[nodiscard]] ResultVal<VirtualFile> OpenCurrentProcess(u64 current_process_title_id) const;
-    [[nodiscard]] ResultVal<VirtualFile> OpenPatchedRomFS(u64 title_id,
-                                                          ContentRecordType type) const;
-    [[nodiscard]] ResultVal<VirtualFile> OpenPatchedRomFSWithProgramIndex(
-        u64 title_id, u8 program_index, ContentRecordType type) const;
-    [[nodiscard]] ResultVal<VirtualFile> Open(u64 title_id, StorageId storage,
+    [[nodiscard]] VirtualFile OpenCurrentProcess(u64 current_process_title_id) const;
+    [[nodiscard]] VirtualFile OpenPatchedRomFS(u64 title_id, ContentRecordType type) const;
+    [[nodiscard]] VirtualFile OpenPatchedRomFSWithProgramIndex(u64 title_id, u8 program_index,
                                                                ContentRecordType type) const;
+    [[nodiscard]] VirtualFile Open(u64 title_id, StorageId storage, ContentRecordType type) const;
 
 private:
     [[nodiscard]] std::shared_ptr<NCA> GetEntry(u64 title_id, StorageId storage,

src/core/file_sys/savedata_factory.cpp

@@ -108,26 +108,16 @@ SaveDataFactory::SaveDataFactory(Core::System& system_, VirtualDir save_director
 
 SaveDataFactory::~SaveDataFactory() = default;
 
-ResultVal<VirtualDir> SaveDataFactory::Create(SaveDataSpaceId space,
-                                              const SaveDataAttribute& meta) const {
+VirtualDir SaveDataFactory::Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
     PrintSaveDataAttributeWarnings(meta);
 
     const auto save_directory =
         GetFullPath(system, dir, space, meta.type, meta.title_id, meta.user_id, meta.save_id);
 
-    auto out = dir->CreateDirectoryRelative(save_directory);
-
-    // Return an error if the save data doesn't actually exist.
-    if (out == nullptr) {
-        // TODO(DarkLordZach): Find out correct error code.
-        return ResultUnknown;
-    }
-
-    return out;
+    return dir->CreateDirectoryRelative(save_directory);
 }
 
-ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
-                                            const SaveDataAttribute& meta) const {
+VirtualDir SaveDataFactory::Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
 
     const auto save_directory =
         GetFullPath(system, dir, space, meta.type, meta.title_id, meta.user_id, meta.save_id);
@@ -138,12 +128,6 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
         return Create(space, meta);
     }
 
-    // Return an error if the save data doesn't actually exist.
-    if (out == nullptr) {
-        // TODO(Subv): Find out correct error code.
-        return ResultUnknown;
-    }
-
     return out;
 }
 

src/core/file_sys/savedata_factory.h

@@ -89,8 +89,8 @@ public:
     explicit SaveDataFactory(Core::System& system_, VirtualDir save_directory_);
     ~SaveDataFactory();
 
-    ResultVal<VirtualDir> Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const;
-    ResultVal<VirtualDir> Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const;
+    VirtualDir Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const;
+    VirtualDir Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const;
 
     VirtualDir GetSaveDataSpaceDirectory(SaveDataSpaceId space) const;
 

src/core/file_sys/sdmc_factory.cpp

@@ -23,7 +23,7 @@ SDMCFactory::SDMCFactory(VirtualDir sd_dir_, VirtualDir sd_mod_dir_)
 
 SDMCFactory::~SDMCFactory() = default;
 
-ResultVal<VirtualDir> SDMCFactory::Open() const {
+VirtualDir SDMCFactory::Open() const {
     return sd_dir;
 }
 

src/core/file_sys/sdmc_factory.h

@@ -18,7 +18,7 @@ public:
     explicit SDMCFactory(VirtualDir sd_dir_, VirtualDir sd_mod_dir_);
     ~SDMCFactory();
 
-    ResultVal<VirtualDir> Open() const;
+    VirtualDir Open() const;
 
     VirtualDir GetSDMCModificationLoadRoot(u64 title_id) const;
     VirtualDir GetSDMCContentDirectory() const;

src/core/hle/kernel/k_page_table.cpp

@@ -768,7 +768,7 @@ Result KPageTable::UnmapProcessMemory(KProcessAddress dst_addr, size_t size,
                                                  m_memory_block_slab_manager, num_allocator_blocks);
     R_TRY(allocator_result);
 
-    CASCADE_CODE(Operate(dst_addr, num_pages, KMemoryPermission::None, OperationType::Unmap));
+    R_TRY(Operate(dst_addr, num_pages, KMemoryPermission::None, OperationType::Unmap));
 
     // Apply the memory block update.
     m_memory_block_manager.Update(std::addressof(allocator), dst_addr, num_pages,

src/core/hle/result.h

@@ -283,159 +283,6 @@ private:
     u32 description_end;
 };
 
-/**
- * This is an optional value type. It holds a `Result` and, if that code is ResultSuccess, it
- * also holds a result of type `T`. If the code is an error code (not ResultSuccess), then trying
- * to access the inner value with operator* is undefined behavior and will assert with Unwrap().
- * Users of this class must be cognizant to check the status of the ResultVal with operator bool(),
- * Code(), Succeeded() or Failed() prior to accessing the inner value.
- *
- * An example of how it could be used:
- * \code
- * ResultVal<int> Frobnicate(float strength) {
- *     if (strength < 0.f || strength > 1.0f) {
- *         // Can't frobnicate too weakly or too strongly
- *         return Result{ErrorModule::Common, 1};
- *     } else {
- *         // Frobnicated! Give caller a cookie
- *         return 42;
- *     }
- * }
- * \endcode
- *
- * \code
- * auto frob_result = Frobnicate(0.75f);
- * if (frob_result) {
- *     // Frobbed ok
- *     printf("My cookie is %d\n", *frob_result);
- * } else {
- *     printf("Guess I overdid it. :( Error code: %ux\n", frob_result.Code().raw);
- * }
- * \endcode
- */
-template <typename T>
-class ResultVal {
-public:
-    constexpr ResultVal() : expected{} {}
-
-    constexpr ResultVal(Result code) : expected{Common::Unexpected(code)} {}
-
-    constexpr ResultVal(ResultRange range) : expected{Common::Unexpected(range)} {}
-
-    template <typename U>
-    constexpr ResultVal(U&& val) : expected{std::forward<U>(val)} {}
-
-    template <typename... Args>
-    constexpr ResultVal(Args&&... args) : expected{std::in_place, std::forward<Args>(args)...} {}
-
-    ~ResultVal() = default;
-
-    constexpr ResultVal(const ResultVal&) = default;
-    constexpr ResultVal(ResultVal&&) = default;
-
-    ResultVal& operator=(const ResultVal&) = default;
-    ResultVal& operator=(ResultVal&&) = default;
-
-    [[nodiscard]] constexpr explicit operator bool() const noexcept {
-        return expected.has_value();
-    }
-
-    [[nodiscard]] constexpr Result Code() const {
-        return expected.has_value() ? ResultSuccess : expected.error();
-    }
-
-    [[nodiscard]] constexpr bool Succeeded() const {
-        return expected.has_value();
-    }
-
-    [[nodiscard]] constexpr bool Failed() const {
-        return !expected.has_value();
-    }
-
-    [[nodiscard]] constexpr T* operator->() {
-        return std::addressof(expected.value());
-    }
-
-    [[nodiscard]] constexpr const T* operator->() const {
-        return std::addressof(expected.value());
-    }
-
-    [[nodiscard]] constexpr T& operator*() & {
-        return *expected;
-    }
-
-    [[nodiscard]] constexpr const T& operator*() const& {
-        return *expected;
-    }
-
-    [[nodiscard]] constexpr T&& operator*() && {
-        return *expected;
-    }
-
-    [[nodiscard]] constexpr const T&& operator*() const&& {
-        return *expected;
-    }
-
-    [[nodiscard]] constexpr T& Unwrap() & {
-        ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal");
-        return expected.value();
-    }
-
-    [[nodiscard]] constexpr const T& Unwrap() const& {
-        ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal");
-        return expected.value();
-    }
-
-    [[nodiscard]] constexpr T&& Unwrap() && {
-        ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal");
-        return std::move(expected.value());
-    }
-
-    [[nodiscard]] constexpr const T&& Unwrap() const&& {
-        ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal");
-        return std::move(expected.value());
-    }
-
-    template <typename U>
-    [[nodiscard]] constexpr T ValueOr(U&& v) const& {
-        return expected.value_or(v);
-    }
-
-    template <typename U>
-    [[nodiscard]] constexpr T ValueOr(U&& v) && {
-        return expected.value_or(v);
-    }
-
-private:
-    // TODO (Morph): Replace this with C++23 std::expected.
-    Common::Expected<T, Result> expected;
-};
-
-/**
- * Check for the success of `source` (which must evaluate to a ResultVal). If it succeeds, unwraps
- * the contained value and assigns it to `target`, which can be either an l-value expression or a
- * variable declaration. If it fails the return code is returned from the current function. Thus it
- * can be used to cascade errors out, achieving something akin to exception handling.
- */
-#define CASCADE_RESULT(target, source)                                                             \
-    auto CONCAT2(check_result_L, __LINE__) = source;                                               \
-    if (CONCAT2(check_result_L, __LINE__).Failed()) {                                              \
-        return CONCAT2(check_result_L, __LINE__).Code();                                           \
-    }                                                                                              \
-    target = std::move(*CONCAT2(check_result_L, __LINE__))
-
-/**
- * Analogous to CASCADE_RESULT, but for a bare Result. The code will be propagated if
- * non-success, or discarded otherwise.
- */
-#define CASCADE_CODE(source)                                                                       \
-    do {                                                                                           \
-        auto CONCAT2(check_result_L, __LINE__) = source;                                           \
-        if (CONCAT2(check_result_L, __LINE__).IsError()) {                                         \
-            return CONCAT2(check_result_L, __LINE__);                                              \
-        }                                                                                          \
-    } while (false)
-
 #define R_SUCCEEDED(res) (static_cast<Result>(res).IsSuccess())
 #define R_FAILED(res) (static_cast<Result>(res).IsFailure())
 

src/core/hle/service/acc/acc.cpp

@@ -765,15 +765,16 @@ Result Module::Interface::InitializeApplicationInfoBase() {
     // TODO(ogniK): This should be changed to reflect the target process for when we have multiple
     // processes emulated. As we don't actually have pid support we should assume we're just using
     // our own process
-    const auto launch_property =
-        system.GetARPManager().GetLaunchProperty(system.GetApplicationProcessProgramID());
+    Glue::ApplicationLaunchProperty launch_property{};
+    const auto result = system.GetARPManager().GetLaunchProperty(
+        &launch_property, system.GetApplicationProcessProgramID());
 
-    if (launch_property.Failed()) {
+    if (result != ResultSuccess) {
         LOG_ERROR(Service_ACC, "Failed to get launch property");
         return Account::ResultInvalidApplication;
     }
 
-    switch (launch_property->base_game_storage_id) {
+    switch (launch_property.base_game_storage_id) {
     case FileSys::StorageId::GameCard:
         application_info.application_type = ApplicationType::GameCard;
         break;
@@ -785,7 +786,7 @@ Result Module::Interface::InitializeApplicationInfoBase() {
         break;
     default:
         LOG_ERROR(Service_ACC, "Invalid game storage ID! storage_id={}",
-                  launch_property->base_game_storage_id);
+                  launch_property.base_game_storage_id);
         return Account::ResultInvalidApplication;
     }
 

src/core/hle/service/am/am.cpp

@@ -1578,11 +1578,13 @@ void IApplicationFunctions::EnsureSaveData(HLERequestContext& ctx) {
     attribute.title_id = system.GetApplicationProcessProgramID();
     attribute.user_id = user_id;
     attribute.type = FileSys::SaveDataType::SaveData;
+
+    FileSys::VirtualDir save_data{};
     const auto res = system.GetFileSystemController().CreateSaveData(
-        FileSys::SaveDataSpaceId::NandUser, attribute);
+        &save_data, FileSys::SaveDataSpaceId::NandUser, attribute);
 
     IPC::ResponseBuilder rb{ctx, 4};
-    rb.Push(res.Code());
+    rb.Push(res);
     rb.Push<u64>(0);
 }
 
@@ -1667,26 +1669,30 @@ void IApplicationFunctions::GetDesiredLanguage(HLERequestContext& ctx) {
     auto app_man = ns_am2->GetApplicationManagerInterface();
 
     // Get desired application language
-    const auto res_lang = app_man->GetApplicationDesiredLanguage(supported_languages);
-    if (res_lang.Failed()) {
+    u8 desired_language{};
+    const auto res_lang =
+        app_man->GetApplicationDesiredLanguage(&desired_language, supported_languages);
+    if (res_lang != ResultSuccess) {
         IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res_lang.Code());
+        rb.Push(res_lang);
         return;
     }
 
     // Convert to settings language code.
-    const auto res_code = app_man->ConvertApplicationLanguageToLanguageCode(*res_lang);
-    if (res_code.Failed()) {
+    u64 language_code{};
+    const auto res_code =
+        app_man->ConvertApplicationLanguageToLanguageCode(&language_code, desired_language);
+    if (res_code != ResultSuccess) {
         IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res_code.Code());
+        rb.Push(res_code);
         return;
     }
 
-    LOG_DEBUG(Service_AM, "got desired_language={:016X}", *res_code);
+    LOG_DEBUG(Service_AM, "got desired_language={:016X}", language_code);
 
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
-    rb.Push(*res_code);
+    rb.Push(language_code);
 }
 
 void IApplicationFunctions::IsGamePlayRecordingSupported(HLERequestContext& ctx) {

src/core/hle/service/filesystem/filesystem.cpp

@@ -57,8 +57,8 @@ Result VfsDirectoryServiceWrapper::CreateFile(const std::string& path_, u64 size
         return FileSys::ERROR_PATH_NOT_FOUND;
     }
 
-    const auto entry_type = GetEntryType(path);
-    if (entry_type.Code() == ResultSuccess) {
+    FileSys::EntryType entry_type;
+    if (GetEntryType(&entry_type, path) == ResultSuccess) {
         return FileSys::ERROR_PATH_ALREADY_EXISTS;
     }
 
@@ -210,8 +210,8 @@ Result VfsDirectoryServiceWrapper::RenameDirectory(const std::string& src_path_,
     return ResultUnknown;
 }
 
-ResultVal<FileSys::VirtualFile> VfsDirectoryServiceWrapper::OpenFile(const std::string& path_,
-                                                                     FileSys::Mode mode) const {
+Result VfsDirectoryServiceWrapper::OpenFile(FileSys::VirtualFile* out_file,
+                                            const std::string& path_, FileSys::Mode mode) const {
     const std::string path(Common::FS::SanitizePath(path_));
     std::string_view npath = path;
     while (!npath.empty() && (npath[0] == '/' || npath[0] == '\\')) {
@@ -224,50 +224,68 @@ ResultVal<FileSys::VirtualFile> VfsDirectoryServiceWrapper::OpenFile(const std::
     }
 
     if (mode == FileSys::Mode::Append) {
-        return std::make_shared<FileSys::OffsetVfsFile>(file, 0, file->GetSize());
+        *out_file = std::make_shared<FileSys::OffsetVfsFile>(file, 0, file->GetSize());
+    } else {
+        *out_file = file;
     }
 
-    return file;
+    return ResultSuccess;
 }
 
-ResultVal<FileSys::VirtualDir> VfsDirectoryServiceWrapper::OpenDirectory(const std::string& path_) {
+Result VfsDirectoryServiceWrapper::OpenDirectory(FileSys::VirtualDir* out_directory,
+                                                 const std::string& path_) {
     std::string path(Common::FS::SanitizePath(path_));
     auto dir = GetDirectoryRelativeWrapped(backing, path);
     if (dir == nullptr) {
         // TODO(DarkLordZach): Find a better error code for this
         return FileSys::ERROR_PATH_NOT_FOUND;
     }
-    return dir;
+    *out_directory = dir;
+    return ResultSuccess;
 }
 
-ResultVal<FileSys::EntryType> VfsDirectoryServiceWrapper::GetEntryType(
+Result VfsDirectoryServiceWrapper::GetEntryType(FileSys::EntryType* out_entry_type,
                                                 const std::string& path_) const {
     std::string path(Common::FS::SanitizePath(path_));
     auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(path));
-    if (dir == nullptr)
-        return FileSys::ERROR_PATH_NOT_FOUND;
-    auto filename = Common::FS::GetFilename(path);
-    // TODO(Subv): Some games use the '/' path, find out what this means.
-    if (filename.empty())
-        return FileSys::EntryType::Directory;
-
-    if (dir->GetFile(filename) != nullptr)
-        return FileSys::EntryType::File;
-    if (dir->GetSubdirectory(filename) != nullptr)
-        return FileSys::EntryType::Directory;
-    return FileSys::ERROR_PATH_NOT_FOUND;
-}
-
-ResultVal<FileSys::FileTimeStampRaw> VfsDirectoryServiceWrapper::GetFileTimeStampRaw(
-    const std::string& path) const {
-    auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(path));
     if (dir == nullptr) {
         return FileSys::ERROR_PATH_NOT_FOUND;
     }
-    if (GetEntryType(path).Failed()) {
+
+    auto filename = Common::FS::GetFilename(path);
+    // TODO(Subv): Some games use the '/' path, find out what this means.
+    if (filename.empty()) {
+        *out_entry_type = FileSys::EntryType::Directory;
+        return ResultSuccess;
+    }
+
+    if (dir->GetFile(filename) != nullptr) {
+        *out_entry_type = FileSys::EntryType::File;
+        return ResultSuccess;
+    }
+
+    if (dir->GetSubdirectory(filename) != nullptr) {
+        *out_entry_type = FileSys::EntryType::Directory;
+        return ResultSuccess;
+    }
+
+    return FileSys::ERROR_PATH_NOT_FOUND;
+}
+
+Result VfsDirectoryServiceWrapper::GetFileTimeStampRaw(
+    FileSys::FileTimeStampRaw* out_file_time_stamp_raw, const std::string& path) const {
+    auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(path));
+    if (dir == nullptr) {
         return FileSys::ERROR_PATH_NOT_FOUND;
     }
-    return dir->GetFileTimeStamp(Common::FS::GetFilename(path));
+
+    FileSys::EntryType entry_type;
+    if (GetEntryType(&entry_type, path) != ResultSuccess) {
+        return FileSys::ERROR_PATH_NOT_FOUND;
+    }
+
+    *out_file_time_stamp_raw = dir->GetFileTimeStamp(Common::FS::GetFilename(path));
+    return ResultSuccess;
 }
 
 FileSystemController::FileSystemController(Core::System& system_) : system{system_} {}
@@ -310,57 +328,54 @@ void FileSystemController::SetPackedUpdate(FileSys::VirtualFile update_raw) {
     romfs_factory->SetPackedUpdate(std::move(update_raw));
 }
 
-ResultVal<FileSys::VirtualFile> FileSystemController::OpenRomFSCurrentProcess() const {
+FileSys::VirtualFile FileSystemController::OpenRomFSCurrentProcess() const {
     LOG_TRACE(Service_FS, "Opening RomFS for current process");
 
     if (romfs_factory == nullptr) {
-        // TODO(bunnei): Find a better error code for this
-        return ResultUnknown;
+        return nullptr;
     }
 
     return romfs_factory->OpenCurrentProcess(system.GetApplicationProcessProgramID());
 }
 
-ResultVal<FileSys::VirtualFile> FileSystemController::OpenPatchedRomFS(
-    u64 title_id, FileSys::ContentRecordType type) const {
+FileSys::VirtualFile FileSystemController::OpenPatchedRomFS(u64 title_id,
+                                                            FileSys::ContentRecordType type) const {
     LOG_TRACE(Service_FS, "Opening patched RomFS for title_id={:016X}", title_id);
 
     if (romfs_factory == nullptr) {
-        // TODO: Find a better error code for this
-        return ResultUnknown;
+        return nullptr;
     }
 
     return romfs_factory->OpenPatchedRomFS(title_id, type);
 }
 
-ResultVal<FileSys::VirtualFile> FileSystemController::OpenPatchedRomFSWithProgramIndex(
+FileSys::VirtualFile FileSystemController::OpenPatchedRomFSWithProgramIndex(
     u64 title_id, u8 program_index, FileSys::ContentRecordType type) const {
     LOG_TRACE(Service_FS, "Opening patched RomFS for title_id={:016X}, program_index={}", title_id,
               program_index);
 
     if (romfs_factory == nullptr) {
-        // TODO: Find a better error code for this
-        return ResultUnknown;
+        return nullptr;
     }
 
     return romfs_factory->OpenPatchedRomFSWithProgramIndex(title_id, program_index, type);
 }
 
-ResultVal<FileSys::VirtualFile> FileSystemController::OpenRomFS(
-    u64 title_id, FileSys::StorageId storage_id, FileSys::ContentRecordType type) const {
+FileSys::VirtualFile FileSystemController::OpenRomFS(u64 title_id, FileSys::StorageId storage_id,
+                                                     FileSys::ContentRecordType type) const {
     LOG_TRACE(Service_FS, "Opening RomFS for title_id={:016X}, storage_id={:02X}, type={:02X}",
               title_id, storage_id, type);
 
     if (romfs_factory == nullptr) {
-        // TODO(bunnei): Find a better error code for this
-        return ResultUnknown;
+        return nullptr;
     }
 
     return romfs_factory->Open(title_id, storage_id, type);
 }
 
-ResultVal<FileSys::VirtualDir> FileSystemController::CreateSaveData(
-    FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& save_struct) const {
+Result FileSystemController::CreateSaveData(FileSys::VirtualDir* out_save_data,
+                                            FileSys::SaveDataSpaceId space,
+                                            const FileSys::SaveDataAttribute& save_struct) const {
     LOG_TRACE(Service_FS, "Creating Save Data for space_id={:01X}, save_struct={}", space,
               save_struct.DebugInfo());
 
@@ -368,11 +383,13 @@ ResultVal<FileSys::VirtualDir> FileSystemController::CreateSaveData(
         return FileSys::ERROR_ENTITY_NOT_FOUND;
     }
 
-    return save_data_factory->Create(space, save_struct);
+    *out_save_data = save_data_factory->Create(space, save_struct);
+    return ResultSuccess;
 }
 
-ResultVal<FileSys::VirtualDir> FileSystemController::OpenSaveData(
-    FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& attribute) const {
+Result FileSystemController::OpenSaveData(FileSys::VirtualDir* out_save_data,
+                                          FileSys::SaveDataSpaceId space,
+                                          const FileSys::SaveDataAttribute& attribute) const {
     LOG_TRACE(Service_FS, "Opening Save Data for space_id={:01X}, save_struct={}", space,
               attribute.DebugInfo());
 
@@ -380,10 +397,11 @@ ResultVal<FileSys::VirtualDir> FileSystemController::OpenSaveData(
         return FileSys::ERROR_ENTITY_NOT_FOUND;
     }
 
-    return save_data_factory->Open(space, attribute);
+    *out_save_data = save_data_factory->Open(space, attribute);
+    return ResultSuccess;
 }
 
-ResultVal<FileSys::VirtualDir> FileSystemController::OpenSaveDataSpace(
+Result FileSystemController::OpenSaveDataSpace(FileSys::VirtualDir* out_save_data_space,
                                                FileSys::SaveDataSpaceId space) const {
     LOG_TRACE(Service_FS, "Opening Save Data Space for space_id={:01X}", space);
 
@@ -391,20 +409,22 @@ ResultVal<FileSys::VirtualDir> FileSystemController::OpenSaveDataSpace(
         return FileSys::ERROR_ENTITY_NOT_FOUND;
     }
 
-    return save_data_factory->GetSaveDataSpaceDirectory(space);
+    *out_save_data_space = save_data_factory->GetSaveDataSpaceDirectory(space);
+    return ResultSuccess;
 }
 
-ResultVal<FileSys::VirtualDir> FileSystemController::OpenSDMC() const {
+Result FileSystemController::OpenSDMC(FileSys::VirtualDir* out_sdmc) const {
     LOG_TRACE(Service_FS, "Opening SDMC");
 
     if (sdmc_factory == nullptr) {
         return FileSys::ERROR_SD_CARD_NOT_FOUND;
     }
 
-    return sdmc_factory->Open();
+    *out_sdmc = sdmc_factory->Open();
+    return ResultSuccess;
 }
 
-ResultVal<FileSys::VirtualDir> FileSystemController::OpenBISPartition(
+Result FileSystemController::OpenBISPartition(FileSys::VirtualDir* out_bis_partition,
                                               FileSys::BisPartitionId id) const {
     LOG_TRACE(Service_FS, "Opening BIS Partition with id={:08X}", id);
 
@@ -417,11 +437,12 @@ ResultVal<FileSys::VirtualDir> FileSystemController::OpenBISPartition(
         return FileSys::ERROR_INVALID_ARGUMENT;
     }
 
-    return part;
+    *out_bis_partition = part;
+    return ResultSuccess;
 }
 
-ResultVal<FileSys::VirtualFile> FileSystemController::OpenBISPartitionStorage(
-    FileSys::BisPartitionId id) const {
+Result FileSystemController::OpenBISPartitionStorage(
+    FileSys::VirtualFile* out_bis_partition_storage, FileSys::BisPartitionId id) const {
     LOG_TRACE(Service_FS, "Opening BIS Partition Storage with id={:08X}", id);
 
     if (bis_factory == nullptr) {
@@ -433,7 +454,8 @@ ResultVal<FileSys::VirtualFile> FileSystemController::OpenBISPartitionStorage(
         return FileSys::ERROR_INVALID_ARGUMENT;
     }
 
-    return part;
+    *out_bis_partition_storage = part;
+    return ResultSuccess;
 }
 
 u64 FileSystemController::GetFreeSpaceSize(FileSys::StorageId id) const {

src/core/hle/service/filesystem/filesystem.h

@@ -64,21 +64,24 @@ public:
     Result RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory);
 
     void SetPackedUpdate(FileSys::VirtualFile update_raw);
-    ResultVal<FileSys::VirtualFile> OpenRomFSCurrentProcess() const;
-    ResultVal<FileSys::VirtualFile> OpenPatchedRomFS(u64 title_id,
+    FileSys::VirtualFile OpenRomFSCurrentProcess() const;
+    FileSys::VirtualFile OpenPatchedRomFS(u64 title_id, FileSys::ContentRecordType type) const;
+    FileSys::VirtualFile OpenPatchedRomFSWithProgramIndex(u64 title_id, u8 program_index,
                                                           FileSys::ContentRecordType type) const;
-    ResultVal<FileSys::VirtualFile> OpenPatchedRomFSWithProgramIndex(
-        u64 title_id, u8 program_index, FileSys::ContentRecordType type) const;
-    ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id, FileSys::StorageId storage_id,
+    FileSys::VirtualFile OpenRomFS(u64 title_id, FileSys::StorageId storage_id,
                                    FileSys::ContentRecordType type) const;
-    ResultVal<FileSys::VirtualDir> CreateSaveData(
-        FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& save_struct) const;
-    ResultVal<FileSys::VirtualDir> OpenSaveData(
-        FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& save_struct) const;
-    ResultVal<FileSys::VirtualDir> OpenSaveDataSpace(FileSys::SaveDataSpaceId space) const;
-    ResultVal<FileSys::VirtualDir> OpenSDMC() const;
-    ResultVal<FileSys::VirtualDir> OpenBISPartition(FileSys::BisPartitionId id) const;
-    ResultVal<FileSys::VirtualFile> OpenBISPartitionStorage(FileSys::BisPartitionId id) const;
+
+    Result CreateSaveData(FileSys::VirtualDir* out_save_data, FileSys::SaveDataSpaceId space,
+                          const FileSys::SaveDataAttribute& save_struct) const;
+    Result OpenSaveData(FileSys::VirtualDir* out_save_data, FileSys::SaveDataSpaceId space,
+                        const FileSys::SaveDataAttribute& save_struct) const;
+    Result OpenSaveDataSpace(FileSys::VirtualDir* out_save_data_space,
+                             FileSys::SaveDataSpaceId space) const;
+    Result OpenSDMC(FileSys::VirtualDir* out_sdmc) const;
+    Result OpenBISPartition(FileSys::VirtualDir* out_bis_partition,
+                            FileSys::BisPartitionId id) const;
+    Result OpenBISPartitionStorage(FileSys::VirtualFile* out_bis_partition_storage,
+                                   FileSys::BisPartitionId id) const;
 
     u64 GetFreeSpaceSize(FileSys::StorageId id) const;
     u64 GetTotalSpaceSize(FileSys::StorageId id) const;
@@ -224,26 +227,28 @@ public:
      * @param mode Mode to open the file with
      * @return Opened file, or error code
      */
-    ResultVal<FileSys::VirtualFile> OpenFile(const std::string& path, FileSys::Mode mode) const;
+    Result OpenFile(FileSys::VirtualFile* out_file, const std::string& path,
+                    FileSys::Mode mode) const;
 
     /**
      * Open a directory specified by its path
      * @param path Path relative to the archive
      * @return Opened directory, or error code
      */
-    ResultVal<FileSys::VirtualDir> OpenDirectory(const std::string& path);
+    Result OpenDirectory(FileSys::VirtualDir* out_directory, const std::string& path);
 
     /**
      * Get the type of the specified path
      * @return The type of the specified path or error code
      */
-    ResultVal<FileSys::EntryType> GetEntryType(const std::string& path) const;
+    Result GetEntryType(FileSys::EntryType* out_entry_type, const std::string& path) const;
 
     /**
      * Get the timestamp of the specified path
      * @return The timestamp of the specified path or error code
      */
-    ResultVal<FileSys::FileTimeStampRaw> GetFileTimeStampRaw(const std::string& path) const;
+    Result GetFileTimeStampRaw(FileSys::FileTimeStampRaw* out_time_stamp_raw,
+                               const std::string& path) const;
 
 private:
     FileSys::VirtualDir backing;

src/core/hle/service/filesystem/fsp_srv.cpp

@@ -419,14 +419,15 @@ public:
 
         LOG_DEBUG(Service_FS, "called. file={}, mode={}", name, mode);
 
-        auto result = backend.OpenFile(name, mode);
-        if (result.Failed()) {
+        FileSys::VirtualFile vfs_file{};
+        auto result = backend.OpenFile(&vfs_file, name, mode);
+        if (result != ResultSuccess) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(result.Code());
+            rb.Push(result);
             return;
         }
 
-        auto file = std::make_shared<IFile>(system, result.Unwrap());
+        auto file = std::make_shared<IFile>(system, vfs_file);
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
@@ -444,14 +445,15 @@ public:
 
         LOG_DEBUG(Service_FS, "called. directory={}, filter={}", name, filter_flags);
 
-        auto result = backend.OpenDirectory(name);
-        if (result.Failed()) {
+        FileSys::VirtualDir vfs_dir{};
+        auto result = backend.OpenDirectory(&vfs_dir, name);
+        if (result != ResultSuccess) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(result.Code());
+            rb.Push(result);
             return;
         }
 
-        auto directory = std::make_shared<IDirectory>(system, result.Unwrap());
+        auto directory = std::make_shared<IDirectory>(system, vfs_dir);
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
@@ -464,16 +466,17 @@ public:
 
         LOG_DEBUG(Service_FS, "called. file={}", name);
 
-        auto result = backend.GetEntryType(name);
-        if (result.Failed()) {
+        FileSys::EntryType vfs_entry_type{};
+        auto result = backend.GetEntryType(&vfs_entry_type, name);
+        if (result != ResultSuccess) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(result.Code());
+            rb.Push(result);
             return;
         }
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(ResultSuccess);
-        rb.Push<u32>(static_cast<u32>(*result));
+        rb.Push<u32>(static_cast<u32>(vfs_entry_type));
     }
 
     void Commit(HLERequestContext& ctx) {
@@ -505,16 +508,17 @@ public:
 
         LOG_WARNING(Service_FS, "(Partial Implementation) called. file={}", name);
 
-        auto result = backend.GetFileTimeStampRaw(name);
-        if (result.Failed()) {
+        FileSys::FileTimeStampRaw vfs_timestamp{};
+        auto result = backend.GetFileTimeStampRaw(&vfs_timestamp, name);
+        if (result != ResultSuccess) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(result.Code());
+            rb.Push(result);
             return;
         }
 
         IPC::ResponseBuilder rb{ctx, 10};
         rb.Push(ResultSuccess);
-        rb.PushRaw(*result);
+        rb.PushRaw(vfs_timestamp);
     }
 
 private:
@@ -572,14 +576,15 @@ private:
     }
 
     void FindAllSaves(FileSys::SaveDataSpaceId space) {
-        const auto save_root = fsc.OpenSaveDataSpace(space);
+        FileSys::VirtualDir save_root{};
+        const auto result = fsc.OpenSaveDataSpace(&save_root, space);
 
-        if (save_root.Failed() || *save_root == nullptr) {
+        if (result != ResultSuccess || save_root == nullptr) {
             LOG_ERROR(Service_FS, "The save root for the space_id={:02X} was invalid!", space);
             return;
         }
 
-        for (const auto& type : (*save_root)->GetSubdirectories()) {
+        for (const auto& type : save_root->GetSubdirectories()) {
             if (type->GetName() == "save") {
                 for (const auto& save_id : type->GetSubdirectories()) {
                     for (const auto& user_id : save_id->GetSubdirectories()) {
@@ -837,9 +842,11 @@ void FSP_SRV::OpenFileSystemWithPatch(HLERequestContext& ctx) {
 void FSP_SRV::OpenSdCardFileSystem(HLERequestContext& ctx) {
     LOG_DEBUG(Service_FS, "called");
 
-    auto filesystem =
-        std::make_shared<IFileSystem>(system, fsc.OpenSDMC().Unwrap(),
-                                      SizeGetter::FromStorageId(fsc, FileSys::StorageId::SdCard));
+    FileSys::VirtualDir sdmc_dir{};
+    fsc.OpenSDMC(&sdmc_dir);
+
+    auto filesystem = std::make_shared<IFileSystem>(
+        system, sdmc_dir, SizeGetter::FromStorageId(fsc, FileSys::StorageId::SdCard));
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
@@ -856,7 +863,8 @@ void FSP_SRV::CreateSaveDataFileSystem(HLERequestContext& ctx) {
     LOG_DEBUG(Service_FS, "called save_struct = {}, uid = {:016X}{:016X}", save_struct.DebugInfo(),
               uid[1], uid[0]);
 
-    fsc.CreateSaveData(FileSys::SaveDataSpaceId::NandUser, save_struct);
+    FileSys::VirtualDir save_data_dir{};
+    fsc.CreateSaveData(&save_data_dir, FileSys::SaveDataSpaceId::NandUser, save_struct);
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(ResultSuccess);
@@ -874,8 +882,9 @@ void FSP_SRV::OpenSaveDataFileSystem(HLERequestContext& ctx) {
 
     LOG_INFO(Service_FS, "called.");
 
-    auto dir = fsc.OpenSaveData(parameters.space_id, parameters.attribute);
-    if (dir.Failed()) {
+    FileSys::VirtualDir dir{};
+    auto result = fsc.OpenSaveData(&dir, parameters.space_id, parameters.attribute);
+    if (result != ResultSuccess) {
         IPC::ResponseBuilder rb{ctx, 2, 0, 0};
         rb.Push(FileSys::ERROR_ENTITY_NOT_FOUND);
         return;
@@ -899,8 +908,8 @@ void FSP_SRV::OpenSaveDataFileSystem(HLERequestContext& ctx) {
         ASSERT(false);
     }
 
-    auto filesystem = std::make_shared<IFileSystem>(system, std::move(dir.Unwrap()),
-                                                    SizeGetter::FromStorageId(fsc, id));
+    auto filesystem =
+        std::make_shared<IFileSystem>(system, std::move(dir), SizeGetter::FromStorageId(fsc, id));
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
@@ -970,7 +979,7 @@ void FSP_SRV::OpenDataStorageByCurrentProcess(HLERequestContext& ctx) {
 
     if (!romfs) {
         auto current_romfs = fsc.OpenRomFSCurrentProcess();
-        if (current_romfs.Failed()) {
+        if (!current_romfs) {
             // TODO (bunnei): Find the right error code to use here
             LOG_CRITICAL(Service_FS, "no file system interface available!");
             IPC::ResponseBuilder rb{ctx, 2};
@@ -978,7 +987,7 @@ void FSP_SRV::OpenDataStorageByCurrentProcess(HLERequestContext& ctx) {
             return;
         }
 
-        romfs = current_romfs.Unwrap();
+        romfs = current_romfs;
     }
 
     auto storage = std::make_shared<IStorage>(system, romfs);
@@ -999,7 +1008,7 @@ void FSP_SRV::OpenDataStorageByDataId(HLERequestContext& ctx) {
 
     auto data = fsc.OpenRomFS(title_id, storage_id, FileSys::ContentRecordType::Data);
 
-    if (data.Failed()) {
+    if (!data) {
         const auto archive = FileSys::SystemArchive::SynthesizeSystemArchive(title_id);
 
         if (archive != nullptr) {
@@ -1021,7 +1030,7 @@ void FSP_SRV::OpenDataStorageByDataId(HLERequestContext& ctx) {
     const FileSys::PatchManager pm{title_id, fsc, content_provider};
 
     auto storage = std::make_shared<IStorage>(
-        system, pm.PatchRomFS(std::move(data.Unwrap()), 0, FileSys::ContentRecordType::Data));
+        system, pm.PatchRomFS(std::move(data), 0, FileSys::ContentRecordType::Data));
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
@@ -1051,7 +1060,7 @@ void FSP_SRV::OpenDataStorageWithProgramIndex(HLERequestContext& ctx) {
         fsc.OpenPatchedRomFSWithProgramIndex(system.GetApplicationProcessProgramID(), program_index,
                                              FileSys::ContentRecordType::Program);
 
-    if (patched_romfs.Failed()) {
+    if (!patched_romfs) {
         // TODO: Find the right error code to use here
         LOG_ERROR(Service_FS, "could not open storage with program_index={}", program_index);
 
@@ -1060,7 +1069,7 @@ void FSP_SRV::OpenDataStorageWithProgramIndex(HLERequestContext& ctx) {
         return;
     }
 
-    auto storage = std::make_shared<IStorage>(system, std::move(patched_romfs.Unwrap()));
+    auto storage = std::make_shared<IStorage>(system, std::move(patched_romfs));
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);

src/core/hle/service/glue/arp.cpp

@@ -65,18 +65,19 @@ void ARP_R::GetApplicationLaunchProperty(HLERequestContext& ctx) {
         return;
     }
 
-    const auto res = manager.GetLaunchProperty(*title_id);
+    ApplicationLaunchProperty launch_property{};
+    const auto res = manager.GetLaunchProperty(&launch_property, *title_id);
 
-    if (res.Failed()) {
+    if (res != ResultSuccess) {
         LOG_ERROR(Service_ARP, "Failed to get launch property!");
         IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res.Code());
+        rb.Push(res);
         return;
     }
 
     IPC::ResponseBuilder rb{ctx, 6};
     rb.Push(ResultSuccess);
-    rb.PushRaw(*res);
+    rb.PushRaw(launch_property);
 }
 
 void ARP_R::GetApplicationLaunchPropertyWithApplicationId(HLERequestContext& ctx) {
@@ -85,18 +86,19 @@ void ARP_R::GetApplicationLaunchPropertyWithApplicationId(HLERequestContext& ctx
 
     LOG_DEBUG(Service_ARP, "called, title_id={:016X}", title_id);
 
-    const auto res = manager.GetLaunchProperty(title_id);
+    ApplicationLaunchProperty launch_property{};
+    const auto res = manager.GetLaunchProperty(&launch_property, title_id);
 
-    if (res.Failed()) {
+    if (res != ResultSuccess) {
         LOG_ERROR(Service_ARP, "Failed to get launch property!");
         IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res.Code());
+        rb.Push(res);
         return;
     }
 
     IPC::ResponseBuilder rb{ctx, 6};
     rb.Push(ResultSuccess);
-    rb.PushRaw(*res);
+    rb.PushRaw(launch_property);
 }
 
 void ARP_R::GetApplicationControlProperty(HLERequestContext& ctx) {
@@ -113,16 +115,17 @@ void ARP_R::GetApplicationControlProperty(HLERequestContext& ctx) {
         return;
     }
 
-    const auto res = manager.GetControlProperty(*title_id);
+    std::vector<u8> nacp_data;
+    const auto res = manager.GetControlProperty(&nacp_data, *title_id);
 
-    if (res.Failed()) {
+    if (res != ResultSuccess) {
         LOG_ERROR(Service_ARP, "Failed to get control property!");
         IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res.Code());
+        rb.Push(res);
         return;
     }
 
-    ctx.WriteBuffer(*res);
+    ctx.WriteBuffer(nacp_data);
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(ResultSuccess);
@@ -134,16 +137,17 @@ void ARP_R::GetApplicationControlPropertyWithApplicationId(HLERequestContext& ct
 
     LOG_DEBUG(Service_ARP, "called, title_id={:016X}", title_id);
 
-    const auto res = manager.GetControlProperty(title_id);
+    std::vector<u8> nacp_data;
+    const auto res = manager.GetControlProperty(&nacp_data, title_id);
 
-    if (res.Failed()) {
+    if (res != ResultSuccess) {
         LOG_ERROR(Service_ARP, "Failed to get control property!");
         IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res.Code());
+        rb.Push(res);
         return;
     }
 
-    ctx.WriteBuffer(*res);
+    ctx.WriteBuffer(nacp_data);
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(ResultSuccess);

src/core/hle/service/glue/glue_manager.cpp

@@ -15,7 +15,8 @@ ARPManager::ARPManager() = default;
 
 ARPManager::~ARPManager() = default;
 
-ResultVal<ApplicationLaunchProperty> ARPManager::GetLaunchProperty(u64 title_id) const {
+Result ARPManager::GetLaunchProperty(ApplicationLaunchProperty* out_launch_property,
+                                     u64 title_id) const {
     if (title_id == 0) {
         return Glue::ResultInvalidProcessId;
     }
@@ -25,10 +26,11 @@ ResultVal<ApplicationLaunchProperty> ARPManager::GetLaunchProperty(u64 title_id)
         return Glue::ResultProcessIdNotRegistered;
     }
 
-    return iter->second.launch;
+    *out_launch_property = iter->second.launch;
+    return ResultSuccess;
 }
 
-ResultVal<std::vector<u8>> ARPManager::GetControlProperty(u64 title_id) const {
+Result ARPManager::GetControlProperty(std::vector<u8>* out_control_property, u64 title_id) const {
     if (title_id == 0) {
         return Glue::ResultInvalidProcessId;
     }
@@ -38,7 +40,8 @@ ResultVal<std::vector<u8>> ARPManager::GetControlProperty(u64 title_id) const {
         return Glue::ResultProcessIdNotRegistered;
     }
 
-    return iter->second.control;
+    *out_control_property = iter->second.control;
+    return ResultSuccess;
 }
 
 Result ARPManager::Register(u64 title_id, ApplicationLaunchProperty launch,

src/core/hle/service/glue/glue_manager.h

@@ -32,12 +32,12 @@ public:
     // Returns the ApplicationLaunchProperty corresponding to the provided title ID if it was
     // previously registered, otherwise ResultProcessIdNotRegistered if it was never registered or
     // ResultInvalidProcessId if the title ID is 0.
-    ResultVal<ApplicationLaunchProperty> GetLaunchProperty(u64 title_id) const;
+    Result GetLaunchProperty(ApplicationLaunchProperty* out_launch_property, u64 title_id) const;
 
     // Returns a vector of the raw bytes of NACP data (necessarily 0x4000 in size) corresponding to
     // the provided title ID if it was previously registered, otherwise ResultProcessIdNotRegistered
     // if it was never registered or ResultInvalidProcessId if the title ID is 0.
-    ResultVal<std::vector<u8>> GetControlProperty(u64 title_id) const;
+    Result GetControlProperty(std::vector<u8>* out_control_property, u64 title_id) const;
 
     // Adds a new entry to the internal database with the provided parameters, returning
     // ResultProcessIdNotRegistered if attempting to re-register a title ID without an intermediate

src/core/hle/service/ldr/ldr.cpp

@@ -357,7 +357,8 @@ public:
         return ResultSuccess;
     }
 
-    ResultVal<VAddr> MapProcessCodeMemory(Kernel::KProcess* process, VAddr base_addr, u64 size) {
+    Result MapProcessCodeMemory(VAddr* out_map_location, Kernel::KProcess* process, VAddr base_addr,
+                                u64 size) {
         auto& page_table{process->GetPageTable()};
         VAddr addr{};
 
@@ -372,20 +373,21 @@ public:
             R_TRY(result);
 
             if (ValidateRegionForMap(page_table, addr, size)) {
-                return addr;
+                *out_map_location = addr;
+                return ResultSuccess;
             }
         }
 
         return ERROR_INSUFFICIENT_ADDRESS_SPACE;
     }
 
-    ResultVal<VAddr> MapNro(Kernel::KProcess* process, VAddr nro_addr, std::size_t nro_size,
-                            VAddr bss_addr, std::size_t bss_size, std::size_t size) {
+    Result MapNro(VAddr* out_map_location, Kernel::KProcess* process, VAddr nro_addr,
+                  std::size_t nro_size, VAddr bss_addr, std::size_t bss_size, std::size_t size) {
         for (std::size_t retry = 0; retry < MAXIMUM_MAP_RETRIES; retry++) {
             auto& page_table{process->GetPageTable()};
             VAddr addr{};
 
-            CASCADE_RESULT(addr, MapProcessCodeMemory(process, nro_addr, nro_size));
+            R_TRY(MapProcessCodeMemory(&addr, process, nro_addr, nro_size));
 
             if (bss_size) {
                 auto block_guard = detail::ScopeExit([&] {
@@ -411,7 +413,8 @@ public:
             }
 
             if (ValidateRegionForMap(page_table, addr, size)) {
-                return addr;
+                *out_map_location = addr;
+                return ResultSuccess;
             }
         }
 
@@ -437,9 +440,9 @@ public:
         CopyCode(nro_addr + nro_header.segment_headers[DATA_INDEX].memory_offset, data_start,
                  nro_header.segment_headers[DATA_INDEX].memory_size);
 
-        CASCADE_CODE(process->GetPageTable().SetProcessMemoryPermission(
+        R_TRY(process->GetPageTable().SetProcessMemoryPermission(
             text_start, ro_start - text_start, Kernel::Svc::MemoryPermission::ReadExecute));
-        CASCADE_CODE(process->GetPageTable().SetProcessMemoryPermission(
+        R_TRY(process->GetPageTable().SetProcessMemoryPermission(
             ro_start, data_start - ro_start, Kernel::Svc::MemoryPermission::Read));
 
         return process->GetPageTable().SetProcessMemoryPermission(
@@ -542,31 +545,32 @@ public:
         }
 
         // Map memory for the NRO
-        const auto map_result{MapNro(system.ApplicationProcess(), nro_address, nro_size,
-                                     bss_address, bss_size, nro_size + bss_size)};
-        if (map_result.Failed()) {
+        VAddr map_location;
+        const auto map_result{MapNro(&map_location, system.ApplicationProcess(), nro_address,
+                                     nro_size, bss_address, bss_size, nro_size + bss_size)};
+        if (map_result != ResultSuccess) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(map_result.Code());
+            rb.Push(map_result);
         }
 
         // Load the NRO into the mapped memory
         if (const auto result{
-                LoadNro(system.ApplicationProcess(), header, nro_address, *map_result)};
+                LoadNro(system.ApplicationProcess(), header, nro_address, map_location)};
             result.IsError()) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(map_result.Code());
+            rb.Push(result);
         }
 
         // Track the loaded NRO
-        nro.insert_or_assign(*map_result,
-                             NROInfo{hash, *map_result, nro_size, bss_address, bss_size,
+        nro.insert_or_assign(map_location,
+                             NROInfo{hash, map_location, nro_size, bss_address, bss_size,
                                      header.segment_headers[TEXT_INDEX].memory_size,
                                      header.segment_headers[RO_INDEX].memory_size,
                                      header.segment_headers[DATA_INDEX].memory_size, nro_address});
 
         IPC::ResponseBuilder rb{ctx, 4};
         rb.Push(ResultSuccess);
-        rb.Push(*map_result);
+        rb.Push(map_location);
     }
 
     Result UnmapNro(const NROInfo& info) {
@@ -574,19 +578,19 @@ public:
         auto& page_table{system.ApplicationProcess()->GetPageTable()};
 
         if (info.bss_size != 0) {
-            CASCADE_CODE(page_table.UnmapCodeMemory(
+            R_TRY(page_table.UnmapCodeMemory(
                 info.nro_address + info.text_size + info.ro_size + info.data_size, info.bss_address,
                 info.bss_size, Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange));
         }
 
-        CASCADE_CODE(page_table.UnmapCodeMemory(
+        R_TRY(page_table.UnmapCodeMemory(
             info.nro_address + info.text_size + info.ro_size,
             info.src_addr + info.text_size + info.ro_size, info.data_size,
             Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange));
-        CASCADE_CODE(page_table.UnmapCodeMemory(
+        R_TRY(page_table.UnmapCodeMemory(
             info.nro_address + info.text_size, info.src_addr + info.text_size, info.ro_size,
             Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange));
-        CASCADE_CODE(page_table.UnmapCodeMemory(
+        R_TRY(page_table.UnmapCodeMemory(
             info.nro_address, info.src_addr, info.text_size,
             Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange));
         return ResultSuccess;

src/core/hle/service/mii/mii.cpp

@@ -101,20 +101,14 @@ private:
 
         LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag);
 
-        const auto result{manager.GetDefault(source_flag)};
-        if (result.Failed()) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(result.Code());
-            return;
-        }
-
-        if (result->size() > 0) {
-            ctx.WriteBuffer(SerializeArray(*result));
+        const auto default_miis{manager.GetDefault(source_flag)};
+        if (default_miis.size() > 0) {
+            ctx.WriteBuffer(SerializeArray(default_miis));
         }
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(ResultSuccess);
-        rb.Push<u32>(static_cast<u32>(result->size()));
+        rb.Push<u32>(static_cast<u32>(default_miis.size()));
     }
 
     void Get1(HLERequestContext& ctx) {
@@ -123,15 +117,10 @@ private:
 
         LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag);
 
-        const auto result{manager.GetDefault(source_flag)};
-        if (result.Failed()) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(result.Code());
-            return;
-        }
+        const auto default_miis{manager.GetDefault(source_flag)};
 
         std::vector<CharInfo> values;
-        for (const auto& element : *result) {
+        for (const auto& element : default_miis) {
             values.emplace_back(element.info);
         }
 
@@ -139,7 +128,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(ResultSuccess);
-        rb.Push<u32>(static_cast<u32>(result->size()));
+        rb.Push<u32>(static_cast<u32>(default_miis.size()));
     }
 
     void UpdateLatest(HLERequestContext& ctx) {
@@ -149,16 +138,17 @@ private:
 
         LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag);
 
-        const auto result{manager.UpdateLatest(info, source_flag)};
-        if (result.Failed()) {
+        CharInfo new_char_info{};
+        const auto result{manager.UpdateLatest(&new_char_info, info, source_flag)};
+        if (result != ResultSuccess) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(result.Code());
+            rb.Push(result);
             return;
         }
 
         IPC::ResponseBuilder rb{ctx, 2 + sizeof(CharInfo) / sizeof(u32)};
         rb.Push(ResultSuccess);
-        rb.PushRaw<CharInfo>(*result);
+        rb.PushRaw<CharInfo>(new_char_info);
     }
 
     void BuildRandom(HLERequestContext& ctx) {

src/core/hle/service/mii/mii_manager.cpp

@@ -409,8 +409,7 @@ u32 MiiManager::GetCount(SourceFlag source_flag) const {
     return static_cast<u32>(count);
 }
 
-ResultVal<CharInfo> MiiManager::UpdateLatest([[maybe_unused]] const CharInfo& info,
-                                             SourceFlag source_flag) {
+Result MiiManager::UpdateLatest(CharInfo* out_info, const CharInfo& info, SourceFlag source_flag) {
     if ((source_flag & SourceFlag::Database) == SourceFlag::None) {
         return ERROR_CANNOT_FIND_ENTRY;
     }
@@ -672,7 +671,7 @@ bool MiiManager::ValidateV3Info(const Ver3StoreData& mii_v3) const {
     return is_valid;
 }
 
-ResultVal<std::vector<MiiInfoElement>> MiiManager::GetDefault(SourceFlag source_flag) {
+std::vector<MiiInfoElement> MiiManager::GetDefault(SourceFlag source_flag) {
     std::vector<MiiInfoElement> result;
 
     if ((source_flag & SourceFlag::Default) == SourceFlag::None) {

src/core/hle/service/mii/mii_manager.h

@@ -19,12 +19,12 @@ public:
     bool CheckAndResetUpdateCounter(SourceFlag source_flag, u64& current_update_counter);
     bool IsFullDatabase() const;
     u32 GetCount(SourceFlag source_flag) const;
-    ResultVal<CharInfo> UpdateLatest(const CharInfo& info, SourceFlag source_flag);
+    Result UpdateLatest(CharInfo* out_info, const CharInfo& info, SourceFlag source_flag);
     CharInfo BuildRandom(Age age, Gender gender, Race race);
     CharInfo BuildDefault(std::size_t index);
     CharInfo ConvertV3ToCharInfo(const Ver3StoreData& mii_v3) const;
     bool ValidateV3Info(const Ver3StoreData& mii_v3) const;
-    ResultVal<std::vector<MiiInfoElement>> GetDefault(SourceFlag source_flag);
+    std::vector<MiiInfoElement> GetDefault(SourceFlag source_flag);
     Result GetIndex(const CharInfo& info, u32& index);
 
     // This is nn::mii::detail::Ver::StoreDataRaw::BuildFromStoreData

src/core/hle/service/ns/ns.cpp

@@ -392,18 +392,19 @@ void IApplicationManagerInterface::GetApplicationDesiredLanguage(HLERequestConte
     IPC::RequestParser rp{ctx};
     const auto supported_languages = rp.Pop<u32>();
 
-    const auto res = GetApplicationDesiredLanguage(supported_languages);
-    if (res.Succeeded()) {
+    u8 desired_language{};
+    const auto res = GetApplicationDesiredLanguage(&desired_language, supported_languages);
+    if (res == ResultSuccess) {
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(ResultSuccess);
-        rb.Push<u32>(*res);
+        rb.Push<u32>(desired_language);
     } else {
         IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res.Code());
+        rb.Push(res);
     }
 }
 
-ResultVal<u8> IApplicationManagerInterface::GetApplicationDesiredLanguage(
+Result IApplicationManagerInterface::GetApplicationDesiredLanguage(u8* out_desired_language,
                                                                    const u32 supported_languages) {
     LOG_DEBUG(Service_NS, "called with supported_languages={:08X}", supported_languages);
 
@@ -430,7 +431,8 @@ ResultVal<u8> IApplicationManagerInterface::GetApplicationDesiredLanguage(
     for (const auto lang : *priority_list) {
         const auto supported_flag = GetSupportedLanguageFlag(lang);
         if (supported_languages == 0 || (supported_languages & supported_flag) == supported_flag) {
-            return static_cast<u8>(lang);
+            *out_desired_language = static_cast<u8>(lang);
+            return ResultSuccess;
         }
     }
 
@@ -444,19 +446,20 @@ void IApplicationManagerInterface::ConvertApplicationLanguageToLanguageCode(
     IPC::RequestParser rp{ctx};
     const auto application_language = rp.Pop<u8>();
 
-    const auto res = ConvertApplicationLanguageToLanguageCode(application_language);
-    if (res.Succeeded()) {
+    u64 language_code{};
+    const auto res = ConvertApplicationLanguageToLanguageCode(&language_code, application_language);
+    if (res == ResultSuccess) {
         IPC::ResponseBuilder rb{ctx, 4};
         rb.Push(ResultSuccess);
-        rb.Push(*res);
+        rb.Push(language_code);
     } else {
         IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res.Code());
+        rb.Push(res);
     }
 }
 
-ResultVal<u64> IApplicationManagerInterface::ConvertApplicationLanguageToLanguageCode(
-    u8 application_language) {
+Result IApplicationManagerInterface::ConvertApplicationLanguageToLanguageCode(
+    u64* out_language_code, u8 application_language) {
     const auto language_code =
         ConvertToLanguageCode(static_cast<ApplicationLanguage>(application_language));
     if (language_code == std::nullopt) {
@@ -464,7 +467,8 @@ ResultVal<u64> IApplicationManagerInterface::ConvertApplicationLanguageToLanguag
         return Service::NS::ResultApplicationLanguageNotFound;
     }
 
-    return static_cast<u64>(*language_code);
+    *out_language_code = static_cast<u64>(*language_code);
+    return ResultSuccess;
 }
 
 IApplicationVersionInterface::IApplicationVersionInterface(Core::System& system_)
@@ -618,12 +622,13 @@ void IReadOnlyApplicationControlDataInterface::GetApplicationControlData(HLERequ
     static_assert(sizeof(RequestParameters) == 0x10, "RequestParameters has incorrect size.");
 
     IPC::RequestParser rp{ctx};
+    std::vector<u8> nacp_data{};
     const auto parameters{rp.PopRaw<RequestParameters>()};
-    const auto nacp_data{system.GetARPManager().GetControlProperty(parameters.application_id)};
-    const auto result = nacp_data ? ResultSuccess : ResultUnknown;
+    const auto result =
+        system.GetARPManager().GetControlProperty(&nacp_data, parameters.application_id);
 
-    if (nacp_data) {
-        ctx.WriteBuffer(nacp_data->data(), nacp_data->size());
+    if (result == ResultSuccess) {
+        ctx.WriteBuffer(nacp_data.data(), nacp_data.size());
     }
 
     IPC::ResponseBuilder rb{ctx, 2};

src/core/hle/service/ns/ns.h

@@ -28,8 +28,9 @@ public:
     explicit IApplicationManagerInterface(Core::System& system_);
     ~IApplicationManagerInterface() override;
 
-    ResultVal<u8> GetApplicationDesiredLanguage(u32 supported_languages);
-    ResultVal<u64> ConvertApplicationLanguageToLanguageCode(u8 application_language);
+    Result GetApplicationDesiredLanguage(u8* out_desired_language, u32 supported_languages);
+    Result ConvertApplicationLanguageToLanguageCode(u64* out_language_code,
+                                                    u8 application_language);
 
 private:
     void GetApplicationControlData(HLERequestContext& ctx);

src/core/hle/service/nvnflinger/nvnflinger.cpp

@@ -183,7 +183,7 @@ std::optional<u32> Nvnflinger::FindBufferQueueId(u64 display_id, u64 layer_id) {
     return layer->GetBinderId();
 }
 
-ResultVal<Kernel::KReadableEvent*> Nvnflinger::FindVsyncEvent(u64 display_id) {
+Result Nvnflinger::FindVsyncEvent(Kernel::KReadableEvent** out_vsync_event, u64 display_id) {
     const auto lock_guard = Lock();
     auto* const display = FindDisplay(display_id);
 
@@ -191,7 +191,7 @@ ResultVal<Kernel::KReadableEvent*> Nvnflinger::FindVsyncEvent(u64 display_id) {
         return VI::ResultNotFound;
     }
 
-    return display->GetVSyncEvent();
+    return display->GetVSyncEvent(out_vsync_event);
 }
 
 VI::Display* Nvnflinger::FindDisplay(u64 display_id) {

src/core/hle/service/nvnflinger/nvnflinger.h

@@ -82,7 +82,7 @@ public:
     ///
     /// If an invalid display ID is provided, then VI::ResultNotFound is returned.
     /// If the vsync event has already been retrieved, then VI::ResultPermissionDenied is returned.
-    [[nodiscard]] ResultVal<Kernel::KReadableEvent*> FindVsyncEvent(u64 display_id);
+    [[nodiscard]] Result FindVsyncEvent(Kernel::KReadableEvent** out_vsync_event, u64 display_id);
 
     /// Performs a composition request to the emulated nvidia GPU and triggers the vsync events when
     /// finished.

src/core/hle/service/server_manager.cpp

@@ -102,16 +102,17 @@ Result ServerManager::RegisterNamedService(const std::string& service_name,
         m_system.ServiceManager().RegisterService(service_name, max_sessions, handler)));
 
     // Get the registered port.
-    auto port = m_system.ServiceManager().GetServicePort(service_name);
-    ASSERT(port.Succeeded());
+    Kernel::KPort* port{};
+    ASSERT(
+        R_SUCCEEDED(m_system.ServiceManager().GetServicePort(std::addressof(port), service_name)));
 
     // Open a new reference to the server port.
-    (*port)->GetServerPort().Open();
+    port->GetServerPort().Open();
 
     // Begin tracking the server port.
     {
         std::scoped_lock ll{m_list_mutex};
-        m_ports.emplace(std::addressof((*port)->GetServerPort()), std::move(handler));
+        m_ports.emplace(std::addressof(port->GetServerPort()), std::move(handler));
     }
 
     // Signal the wakeup event.

src/core/hle/service/sm/sm.cpp

@@ -52,8 +52,7 @@ static Result ValidateServiceName(const std::string& name) {
 
 Result ServiceManager::RegisterService(std::string name, u32 max_sessions,
                                        SessionRequestHandlerPtr handler) {
-
-    CASCADE_CODE(ValidateServiceName(name));
+    R_TRY(ValidateServiceName(name));
 
     std::scoped_lock lk{lock};
     if (registered_services.find(name) != registered_services.end()) {
@@ -77,7 +76,7 @@ Result ServiceManager::RegisterService(std::string name, u32 max_sessions,
 }
 
 Result ServiceManager::UnregisterService(const std::string& name) {
-    CASCADE_CODE(ValidateServiceName(name));
+    R_TRY(ValidateServiceName(name));
 
     std::scoped_lock lk{lock};
     const auto iter = registered_services.find(name);
@@ -92,8 +91,8 @@ Result ServiceManager::UnregisterService(const std::string& name) {
     return ResultSuccess;
 }
 
-ResultVal<Kernel::KPort*> ServiceManager::GetServicePort(const std::string& name) {
-    CASCADE_CODE(ValidateServiceName(name));
+Result ServiceManager::GetServicePort(Kernel::KPort** out_port, const std::string& name) {
+    R_TRY(ValidateServiceName(name));
 
     std::scoped_lock lk{lock};
     auto it = service_ports.find(name);
@@ -102,7 +101,8 @@ ResultVal<Kernel::KPort*> ServiceManager::GetServicePort(const std::string& name
         return Service::SM::ResultNotRegistered;
     }
 
-    return it->second;
+    *out_port = it->second;
+    return ResultSuccess;
 }
 
 /**
@@ -122,32 +122,34 @@ void SM::Initialize(HLERequestContext& ctx) {
 }
 
 void SM::GetService(HLERequestContext& ctx) {
-    auto result = GetServiceImpl(ctx);
+    Kernel::KClientSession* client_session{};
+    auto result = GetServiceImpl(&client_session, ctx);
     if (ctx.GetIsDeferred()) {
         // Don't overwrite the command buffer.
         return;
     }
 
-    if (result.Succeeded()) {
+    if (result == ResultSuccess) {
         IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles};
-        rb.Push(result.Code());
-        rb.PushMoveObjects(result.Unwrap());
+        rb.Push(result);
+        rb.PushMoveObjects(client_session);
     } else {
         IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result.Code());
+        rb.Push(result);
     }
 }
 
 void SM::GetServiceTipc(HLERequestContext& ctx) {
-    auto result = GetServiceImpl(ctx);
+    Kernel::KClientSession* client_session{};
+    auto result = GetServiceImpl(&client_session, ctx);
     if (ctx.GetIsDeferred()) {
         // Don't overwrite the command buffer.
         return;
     }
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles};
-    rb.Push(result.Code());
-    rb.PushMoveObjects(result.Succeeded() ? result.Unwrap() : nullptr);
+    rb.Push(result);
+    rb.PushMoveObjects(result == ResultSuccess ? client_session : nullptr);
 }
 
 static std::string PopServiceName(IPC::RequestParser& rp) {
@@ -161,7 +163,7 @@ static std::string PopServiceName(IPC::RequestParser& rp) {
     return result;
 }
 
-ResultVal<Kernel::KClientSession*> SM::GetServiceImpl(HLERequestContext& ctx) {
+Result SM::GetServiceImpl(Kernel::KClientSession** out_client_session, HLERequestContext& ctx) {
     if (!ctx.GetManager()->GetIsInitializedForSm()) {
         return Service::SM::ResultInvalidClient;
     }
@@ -170,18 +172,18 @@ ResultVal<Kernel::KClientSession*> SM::GetServiceImpl(HLERequestContext& ctx) {
     std::string name(PopServiceName(rp));
 
     // Find the named port.
-    auto port_result = service_manager.GetServicePort(name);
-    if (port_result.Code() == Service::SM::ResultInvalidServiceName) {
+    Kernel::KPort* port{};
+    auto port_result = service_manager.GetServicePort(&port, name);
+    if (port_result == Service::SM::ResultInvalidServiceName) {
         LOG_ERROR(Service_SM, "Invalid service name '{}'", name);
         return Service::SM::ResultInvalidServiceName;
     }
 
-    if (port_result.Failed()) {
+    if (port_result != ResultSuccess) {
         LOG_INFO(Service_SM, "Waiting for service {} to become available", name);
         ctx.SetIsDeferred();
         return Service::SM::ResultNotRegistered;
     }
-    auto& port = port_result.Unwrap();
 
     // Create a new session.
     Kernel::KClientSession* session{};
@@ -192,7 +194,8 @@ ResultVal<Kernel::KClientSession*> SM::GetServiceImpl(HLERequestContext& ctx) {
 
     LOG_DEBUG(Service_SM, "called service={} -> session={}", name, session->GetId());
 
-    return session;
+    *out_client_session = session;
+    return ResultSuccess;
 }
 
 void SM::RegisterService(HLERequestContext& ctx) {

src/core/hle/service/sm/sm.h

@@ -42,7 +42,7 @@ private:
     void RegisterService(HLERequestContext& ctx);
     void UnregisterService(HLERequestContext& ctx);
 
-    ResultVal<Kernel::KClientSession*> GetServiceImpl(HLERequestContext& ctx);
+    Result GetServiceImpl(Kernel::KClientSession** out_client_session, HLERequestContext& ctx);
 
     ServiceManager& service_manager;
     Kernel::KernelCore& kernel;
@@ -55,7 +55,7 @@ public:
 
     Result RegisterService(std::string name, u32 max_sessions, SessionRequestHandlerPtr handler);
     Result UnregisterService(const std::string& name);
-    ResultVal<Kernel::KPort*> GetServicePort(const std::string& name);
+    Result GetServicePort(Kernel::KPort** out_port, const std::string& name);
 
     template <Common::DerivedFrom<SessionRequestHandler> T>
     std::shared_ptr<T> GetService(const std::string& service_name) const {

src/core/hle/service/spl/spl_module.cpp

@@ -30,10 +30,10 @@ void Module::Interface::GetConfig(HLERequestContext& ctx) {
 
     // This should call svcCallSecureMonitor with the appropriate args.
     // Since we do not have it implemented yet, we will use this for now.
-    const auto smc_result = GetConfigImpl(config_item);
-    const auto result_code = smc_result.Code();
+    u64 smc_result{};
+    const auto result_code = GetConfigImpl(&smc_result, config_item);
 
-    if (smc_result.Failed()) {
+    if (result_code != ResultSuccess) {
         LOG_ERROR(Service_SPL, "called, config_item={}, result_code={}", config_item,
                   result_code.raw);
 
@@ -42,11 +42,11 @@ void Module::Interface::GetConfig(HLERequestContext& ctx) {
     }
 
     LOG_DEBUG(Service_SPL, "called, config_item={}, result_code={}, smc_result={}", config_item,
-              result_code.raw, *smc_result);
+              result_code.raw, smc_result);
 
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(result_code);
-    rb.Push(*smc_result);
+    rb.Push(smc_result);
 }
 
 void Module::Interface::ModularExponentiate(HLERequestContext& ctx) {
@@ -99,7 +99,7 @@ void Module::Interface::GetBootReason(HLERequestContext& ctx) {
     rb.Push(ResultSecureMonitorNotImplemented);
 }
 
-ResultVal<u64> Module::Interface::GetConfigImpl(ConfigItem config_item) const {
+Result Module::Interface::GetConfigImpl(u64* out_config, ConfigItem config_item) const {
     switch (config_item) {
     case ConfigItem::DisableProgramVerification:
     case ConfigItem::DramId:
@@ -121,40 +121,50 @@ ResultVal<u64> Module::Interface::GetConfigImpl(ConfigItem config_item) const {
         return ResultSecureMonitorNotImplemented;
     case ConfigItem::ExosphereApiVersion:
         // Get information about the current exosphere version.
-        return (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MAJOR} << 56) |
+        *out_config = (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MAJOR} << 56) |
                       (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MINOR} << 48) |
                       (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MICRO} << 40) |
                       (static_cast<u64>(HLE::ApiVersion::GetTargetFirmware()));
+        return ResultSuccess;
     case ConfigItem::ExosphereNeedsReboot:
         // We are executing, so we aren't in the process of rebooting.
-        return u64{0};
+        *out_config = u64{0};
+        return ResultSuccess;
     case ConfigItem::ExosphereNeedsShutdown:
         // We are executing, so we aren't in the process of shutting down.
-        return u64{0};
+        *out_config = u64{0};
+        return ResultSuccess;
     case ConfigItem::ExosphereGitCommitHash:
         // Get information about the current exosphere git commit hash.
-        return u64{0};
+        *out_config = u64{0};
+        return ResultSuccess;
     case ConfigItem::ExosphereHasRcmBugPatch:
         // Get information about whether this unit has the RCM bug patched.
-        return u64{0};
+        *out_config = u64{0};
+        return ResultSuccess;
     case ConfigItem::ExosphereBlankProdInfo:
         // Get whether this unit should simulate a "blanked" PRODINFO.
-        return u64{0};
+        *out_config = u64{0};
+        return ResultSuccess;
     case ConfigItem::ExosphereAllowCalWrites:
         // Get whether this unit should allow writing to the calibration partition.
-        return u64{0};
+        *out_config = u64{0};
+        return ResultSuccess;
     case ConfigItem::ExosphereEmummcType:
         // Get what kind of emummc this unit has active.
-        return u64{0};
+        *out_config = u64{0};
+        return ResultSuccess;
     case ConfigItem::ExospherePayloadAddress:
         // Gets the physical address of the reboot payload buffer, if one exists.
         return ResultSecureMonitorNotInitialized;
     case ConfigItem::ExosphereLogConfiguration:
         // Get the log configuration.
-        return u64{0};
+        *out_config = u64{0};
+        return ResultSuccess;
     case ConfigItem::ExosphereForceEnableUsb30:
         // Get whether usb 3.0 should be force-enabled.
-        return u64{0};
+        *out_config = u64{0};
+        return ResultSuccess;
     default:
         return ResultSecureMonitorInvalidArgument;
     }

src/core/hle/service/spl/spl_module.h

@@ -35,7 +35,7 @@ public:
         std::shared_ptr<Module> module;
 
     private:
-        ResultVal<u64> GetConfigImpl(ConfigItem config_item) const;
+        Result GetConfigImpl(u64* out_config, ConfigItem config_item) const;
 
         std::mt19937 rng;
     };

src/core/hle/service/vi/display/vi_display.cpp

@@ -58,14 +58,15 @@ const Layer& Display::GetLayer(std::size_t index) const {
     return *layers.at(index);
 }
 
-ResultVal<Kernel::KReadableEvent*> Display::GetVSyncEvent() {
+Result Display::GetVSyncEvent(Kernel::KReadableEvent** out_vsync_event) {
     if (got_vsync_event) {
         return ResultPermissionDenied;
     }
 
     got_vsync_event = true;
 
-    return GetVSyncEventUnchecked();
+    *out_vsync_event = GetVSyncEventUnchecked();
+    return ResultSuccess;
 }
 
 Kernel::KReadableEvent* Display::GetVSyncEventUnchecked() {

src/core/hle/service/vi/display/vi_display.h

@@ -85,7 +85,7 @@ public:
      * @returns The internal Vsync event if it has not yet been retrieved,
      *          VI::ResultPermissionDenied otherwise.
      */
-    [[nodiscard]] ResultVal<Kernel::KReadableEvent*> GetVSyncEvent();
+    [[nodiscard]] Result GetVSyncEvent(Kernel::KReadableEvent** out_vsync_event);
 
     /// Gets the internal vsync event.
     Kernel::KReadableEvent* GetVSyncEventUnchecked();

src/core/hle/service/vi/vi.cpp

@@ -683,9 +683,9 @@ private:
 
         LOG_DEBUG(Service_VI, "called. display_id={}", display_id);
 
-        const auto vsync_event = nv_flinger.FindVsyncEvent(display_id);
-        if (vsync_event.Failed()) {
-            const auto result = vsync_event.Code();
+        Kernel::KReadableEvent* vsync_event{};
+        const auto result = nv_flinger.FindVsyncEvent(&vsync_event, display_id);
+        if (result != ResultSuccess) {
             if (result == ResultNotFound) {
                 LOG_ERROR(Service_VI, "Vsync event was not found for display_id={}", display_id);
             }
@@ -705,15 +705,16 @@ private:
         const auto mode = rp.PopEnum<NintendoScaleMode>();
         LOG_DEBUG(Service_VI, "called mode={}", mode);
 
-        const auto converted_mode = ConvertScalingModeImpl(mode);
+        ConvertedScaleMode converted_mode{};
+        const auto result = ConvertScalingModeImpl(&converted_mode, mode);
 
-        if (converted_mode.Succeeded()) {
+        if (result == ResultSuccess) {
             IPC::ResponseBuilder rb{ctx, 4};
             rb.Push(ResultSuccess);
-            rb.PushEnum(*converted_mode);
+            rb.PushEnum(converted_mode);
         } else {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(converted_mode.Code());
+            rb.Push(result);
         }
     }
 
@@ -760,18 +761,24 @@ private:
         rb.Push(alignment);
     }
 
-    static ResultVal<ConvertedScaleMode> ConvertScalingModeImpl(NintendoScaleMode mode) {
+    static Result ConvertScalingModeImpl(ConvertedScaleMode* out_scaling_mode,
+                                         NintendoScaleMode mode) {
         switch (mode) {
         case NintendoScaleMode::None:
-            return ConvertedScaleMode::None;
+            *out_scaling_mode = ConvertedScaleMode::None;
+            return ResultSuccess;
         case NintendoScaleMode::Freeze:
-            return ConvertedScaleMode::Freeze;
+            *out_scaling_mode = ConvertedScaleMode::Freeze;
+            return ResultSuccess;
         case NintendoScaleMode::ScaleToWindow:
-            return ConvertedScaleMode::ScaleToWindow;
+            *out_scaling_mode = ConvertedScaleMode::ScaleToWindow;
+            return ResultSuccess;
         case NintendoScaleMode::ScaleAndCrop:
-            return ConvertedScaleMode::ScaleAndCrop;
+            *out_scaling_mode = ConvertedScaleMode::ScaleAndCrop;
+            return ResultSuccess;
         case NintendoScaleMode::PreserveAspectRatio:
-            return ConvertedScaleMode::PreserveAspectRatio;
+            *out_scaling_mode = ConvertedScaleMode::PreserveAspectRatio;
+            return ResultSuccess;
         default:
             LOG_ERROR(Service_VI, "Invalid scaling mode specified, mode={}", mode);
             return ResultOperationFailed;