Manually tweak source formatting and then re-run clang-format

src/core/hle/kernel/address_arbiter.cpp

@@ -16,10 +16,8 @@
 
 namespace Kernel {
 
-AddressArbiter::AddressArbiter() {
-}
-AddressArbiter::~AddressArbiter() {
-}
+AddressArbiter::AddressArbiter() {}
+AddressArbiter::~AddressArbiter() {}
 
 SharedPtr<AddressArbiter> AddressArbiter::Create(std::string name) {
     SharedPtr<AddressArbiter> address_arbiter(new AddressArbiter);

src/core/hle/kernel/client_port.cpp

@@ -10,9 +10,7 @@
 
 namespace Kernel {
 
-ClientPort::ClientPort() {
-}
-ClientPort::~ClientPort() {
-}
+ClientPort::ClientPort() {}
+ClientPort::~ClientPort() {}
 
 } // namespace

src/core/hle/kernel/event.cpp

@@ -14,10 +14,8 @@
 
 namespace Kernel {
 
-Event::Event() {
-}
-Event::~Event() {
-}
+Event::Event() {}
+Event::~Event() {}
 
 SharedPtr<Event> Event::Create(ResetType reset_type, std::string name) {
     SharedPtr<Event> evt(new Event);

src/core/hle/kernel/kernel.h

@@ -58,8 +58,7 @@ enum {
 
 class Object : NonCopyable {
 public:
-    virtual ~Object() {
-    }
+    virtual ~Object() {}
 
     /// Returns a unique identifier for the object. For debugging purposes only.
     unsigned int GetObjectId() const {

src/core/hle/kernel/mutex.cpp

@@ -33,10 +33,8 @@ void ReleaseThreadMutexes(Thread* thread) {
     thread->held_mutexes.clear();
 }
 
-Mutex::Mutex() {
-}
-Mutex::~Mutex() {
-}
+Mutex::Mutex() {}
+Mutex::~Mutex() {}
 
 SharedPtr<Mutex> Mutex::Create(bool initial_locked, std::string name) {
     SharedPtr<Mutex> mutex(new Mutex);

src/core/hle/kernel/process.cpp

@@ -26,10 +26,8 @@ SharedPtr<CodeSet> CodeSet::Create(std::string name, u64 program_id) {
     return codeset;
 }
 
-CodeSet::CodeSet() {
-}
-CodeSet::~CodeSet() {
-}
+CodeSet::CodeSet() {}
+CodeSet::~CodeSet() {}
 
 u32 Process::next_process_id;
 
@@ -282,10 +280,8 @@ ResultCode Process::LinearFree(VAddr target, u32 size) {
     return RESULT_SUCCESS;
 }
 
-Kernel::Process::Process() {
-}
-Kernel::Process::~Process() {
-}
+Kernel::Process::Process() {}
+Kernel::Process::~Process() {}
 
 SharedPtr<Process> g_current_process;
 }

src/core/hle/kernel/resource_limit.cpp

@@ -12,10 +12,8 @@ namespace Kernel {
 
 static SharedPtr<ResourceLimit> resource_limits[4];
 
-ResourceLimit::ResourceLimit() {
-}
-ResourceLimit::~ResourceLimit() {
-}
+ResourceLimit::ResourceLimit() {}
+ResourceLimit::~ResourceLimit() {}
 
 SharedPtr<ResourceLimit> ResourceLimit::Create(std::string name) {
     SharedPtr<ResourceLimit> resource_limit(new ResourceLimit);
@@ -150,7 +148,6 @@ void ResourceLimitsInit() {
     resource_limits[static_cast<u8>(ResourceLimitCategory::OTHER)] = resource_limit;
 }
 
-void ResourceLimitsShutdown() {
-}
+void ResourceLimitsShutdown() {}
 
 } // namespace

src/core/hle/kernel/resource_limit.h

@@ -92,8 +92,8 @@ public:
     s32 max_cpu_time = 0;
 
     // TODO(Subv): Increment these in their respective Kernel::T::Create functions, keeping in mind
-    // that
-    // APPLICATION resource limits should not be affected by the objects created by service modules.
+    // that APPLICATION resource limits should not be affected by the objects created by service
+    // modules.
     // Currently we have no way of distinguishing if a Create was called by the running application,
     // or by a service module. Approach this once we have separated the service modules into their
     // own processes

src/core/hle/kernel/semaphore.cpp

@@ -10,10 +10,8 @@
 
 namespace Kernel {
 
-Semaphore::Semaphore() {
-}
-Semaphore::~Semaphore() {
-}
+Semaphore::Semaphore() {}
+Semaphore::~Semaphore() {}
 
 ResultVal<SharedPtr<Semaphore>> Semaphore::Create(s32 initial_count, s32 max_count,
                                                   std::string name) {

src/core/hle/kernel/server_port.cpp

@@ -13,10 +13,8 @@
 
 namespace Kernel {
 
-ServerPort::ServerPort() {
-}
-ServerPort::~ServerPort() {
-}
+ServerPort::ServerPort() {}
+ServerPort::~ServerPort() {}
 
 bool ServerPort::ShouldWait() {
     // If there are no pending sessions, we wait until a new one is added.
@@ -27,8 +25,9 @@ void ServerPort::Acquire() {
     ASSERT_MSG(!ShouldWait(), "object unavailable!");
 }
 
-std::tuple<SharedPtr<ServerPort>, SharedPtr<ClientPort>>
-ServerPort::CreatePortPair(u32 max_sessions, std::string name) {
+std::tuple<SharedPtr<ServerPort>, SharedPtr<ClientPort>> ServerPort::CreatePortPair(
+    u32 max_sessions, std::string name) {
+
     SharedPtr<ServerPort> server_port(new ServerPort);
     SharedPtr<ClientPort> client_port(new ClientPort);
 

src/core/hle/kernel/server_port.h

@@ -23,8 +23,8 @@ public:
      * @param name Optional name of the ports
      * @return The created port tuple
      */
-    static std::tuple<SharedPtr<ServerPort>, SharedPtr<ClientPort>>
-    CreatePortPair(u32 max_sessions, std::string name = "UnknownPort");
+    static std::tuple<SharedPtr<ServerPort>, SharedPtr<ClientPort>> CreatePortPair(
+        u32 max_sessions, std::string name = "UnknownPort");
 
     std::string GetTypeName() const override {
         return "ServerPort";

src/core/hle/kernel/session.cpp

@@ -7,8 +7,6 @@
 
 namespace Kernel {
 
-Session::Session() {
-}
-Session::~Session() {
-}
+Session::Session() {}
+Session::~Session() {}
 }

src/core/hle/kernel/shared_memory.cpp

@@ -12,10 +12,8 @@
 
 namespace Kernel {
 
-SharedMemory::SharedMemory() {
-}
-SharedMemory::~SharedMemory() {
-}
+SharedMemory::SharedMemory() {}
+SharedMemory::~SharedMemory() {}
 
 SharedPtr<SharedMemory> SharedMemory::Create(SharedPtr<Process> owner_process, u32 size,
                                              MemoryPermission permissions,

src/core/hle/kernel/thread.cpp

@@ -61,10 +61,8 @@ inline static u32 const NewThreadId() {
     return next_thread_id++;
 }
 
-Thread::Thread() {
-}
-Thread::~Thread() {
-}
+Thread::Thread() {}
+Thread::~Thread() {}
 
 Thread* GetCurrentThread() {
     return current_thread;

src/core/hle/kernel/timer.cpp

@@ -20,10 +20,8 @@ static int timer_callback_event_type;
 //               us to simply use a pool index or similar.
 static Kernel::HandleTable timer_callback_handle_table;
 
-Timer::Timer() {
-}
-Timer::~Timer() {
-}
+Timer::Timer() {}
+Timer::~Timer() {}
 
 SharedPtr<Timer> Timer::Create(ResetType reset_type, std::string name) {
     SharedPtr<Timer> timer(new Timer);
@@ -103,7 +101,6 @@ void TimersInit() {
     timer_callback_event_type = CoreTiming::RegisterEvent("TimerCallback", TimerCallback);
 }
 
-void TimersShutdown() {
-}
+void TimersShutdown() {}
 
 } // namespace