[core/hle/service] remove duplicate Core::System& from some ServiceFramework (#4171)

services inheriting from ServiceFramework already have an accessible
system pointer from the inheritance
adding an extra pointer (m_system, often) isn't required and tis
entirely redundant.

Signed-off-by: lizzie <lizzie@eden-emu.dev>

Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4171
Reviewed-by: MaranBr <maranbr@eden-emu.dev>
Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>

src/core/hle/service/glue/time/time_zone.cpp

@@ -23,11 +23,13 @@ TimeZoneService::TimeZoneService(
     Core::System& system_, FileTimestampWorker& file_timestamp_worker,
     bool can_write_timezone_device_location, TimeZoneBinary& time_zone_binary,
     std::shared_ptr<Service::PSC::Time::TimeZoneService> time_zone_service)
-    : ServiceFramework{system_, "ITimeZoneService"}, m_system{system},
-      m_can_write_timezone_device_location{can_write_timezone_device_location},
-      m_file_timestamp_worker{file_timestamp_worker}, m_wrapped_service{std::move(
-                                                          time_zone_service)},
-      m_operation_event{m_system}, m_time_zone_binary{time_zone_binary} {
+    : ServiceFramework{system_, "ITimeZoneService"}
+    , m_can_write_timezone_device_location{can_write_timezone_device_location}
+    , m_file_timestamp_worker{file_timestamp_worker}
+    , m_wrapped_service{std::move(time_zone_service)}
+    , m_operation_event{system}
+    , m_time_zone_binary{time_zone_binary}
+{
     // clang-format off
     static const FunctionInfo functions[] = {
         {0,   D<&TimeZoneService::GetDeviceLocationName>, "GetDeviceLocationName"},
@@ -48,8 +50,7 @@ TimeZoneService::TimeZoneService(
     // clang-format on
     RegisterHandlers(functions);
 
-    m_set_sys =
-        m_system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>("set:sys", true);
+    m_set_sys = system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>("set:sys", true);
 }
 
 TimeZoneService::~TimeZoneService() = default;
@@ -89,7 +90,7 @@ Result TimeZoneService::SetDeviceLocationName(
 
     std::scoped_lock m{m_list_mutex};
     for (auto& operation_event : m_list_nodes) {
-        operation_event.m_event->Signal(m_system.Kernel());
+        operation_event.m_event->Signal(system.Kernel());
     }
     R_SUCCEED();
 }

src/core/hle/service/glue/time/time_zone.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -77,9 +80,7 @@ public:
                                  const Service::PSC::Time::CalendarTime& calendar_time);
 
 private:
-    Core::System& m_system;
     std::shared_ptr<Service::Set::ISystemSettingsServer> m_set_sys;
-
     bool m_can_write_timezone_device_location;
     FileTimestampWorker& m_file_timestamp_worker;
     std::shared_ptr<Service::PSC::Time::TimeZoneService> m_wrapped_service;

src/core/hle/service/psc/time/alarms.cpp

@@ -32,11 +32,13 @@ Alarm::~Alarm() {
     m_ctx.CloseEvent(m_event);
 }
 
-Alarms::Alarms(Core::System& system, StandardSteadyClockCore& steady_clock,
-               PowerStateRequestManager& power_state_request_manager)
-    : m_system{system}, m_ctx{system, "Psc:Alarms"}, m_steady_clock{steady_clock},
-      m_power_state_request_manager{power_state_request_manager}, m_event{m_ctx.CreateEvent(
-                                                                      "Psc:Alarms:Event")} {}
+Alarms::Alarms(Core::System& system, StandardSteadyClockCore& steady_clock, PowerStateRequestManager& power_state_request_manager)
+    : m_system{system}
+    , m_ctx{system, "Psc:Alarms"}
+    , m_steady_clock{steady_clock}
+    , m_power_state_request_manager{power_state_request_manager}
+    , m_event{m_ctx.CreateEvent("Psc:Alarms:Event")}
+{}
 
 Alarms::~Alarms() {
     m_ctx.CloseEvent(m_event);
@@ -132,7 +134,9 @@ Result Alarms::UpdateClosestAndSignal(Kernel::KernelCore& kernel) {
 }
 
 IAlarmService::IAlarmService(Core::System& system_, std::shared_ptr<TimeManager> manager)
-    : ServiceFramework{system_, "time:al"}, m_system{system}, m_alarms{manager->m_alarms} {
+    : ServiceFramework{system_, "time:al"}
+    , m_alarms{manager->m_alarms}
+{
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, &IAlarmService::CreateWakeupAlarm, "CreateWakeupAlarm"},

src/core/hle/service/psc/time/alarms.h

@@ -74,8 +74,7 @@ struct Alarm : public Common::IntrusiveListBaseNode<Alarm> {
 
 class Alarms {
 public:
-    explicit Alarms(Core::System& system, StandardSteadyClockCore& steady_clock,
-                    PowerStateRequestManager& power_state_request_manager);
+    explicit Alarms(Core::System& system, StandardSteadyClockCore& steady_clock, PowerStateRequestManager& power_state_request_manager);
     ~Alarms();
 
     Kernel::KEvent& GetEvent() {
@@ -110,21 +109,17 @@ private:
 class IAlarmService final : public ServiceFramework<IAlarmService> {
 public:
     explicit IAlarmService(Core::System& system, std::shared_ptr<TimeManager> manager);
-
     ~IAlarmService() override = default;
 
 private:
     void CreateWakeupAlarm(HLERequestContext& ctx);
     void CreateBackgroundTaskAlarm(HLERequestContext& ctx);
-
-    Core::System& m_system;
     Alarms& m_alarms;
 };
 
 class ISteadyClockAlarm final : public ServiceFramework<ISteadyClockAlarm> {
 public:
     explicit ISteadyClockAlarm(Core::System& system, Alarms& alarms, AlarmType type);
-
     ~ISteadyClockAlarm() override = default;
 
 private:

src/core/hle/service/psc/time/power_state_service.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -8,8 +11,9 @@ namespace Service::PSC::Time {
 
 IPowerStateRequestHandler::IPowerStateRequestHandler(
     Core::System& system_, PowerStateRequestManager& power_state_request_manager)
-    : ServiceFramework{system_, "time:p"}, m_system{system}, m_power_state_request_manager{
-                                                                 power_state_request_manager} {
+    : ServiceFramework{system_, "time:p"}
+    , m_power_state_request_manager{power_state_request_manager}
+{
     // clang-format off
         static const FunctionInfo functions[] = {
             {0, D<&IPowerStateRequestHandler::GetPowerStateRequestEventReadableHandle>, "GetPowerStateRequestEventReadableHandle"},

src/core/hle/service/psc/time/power_state_service.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -17,16 +20,13 @@ namespace Service::PSC::Time {
 
 class IPowerStateRequestHandler final : public ServiceFramework<IPowerStateRequestHandler> {
 public:
-    explicit IPowerStateRequestHandler(Core::System& system,
-                                       PowerStateRequestManager& power_state_request_manager);
-
+    explicit IPowerStateRequestHandler(Core::System& system, PowerStateRequestManager& power_state_request_manager);
     ~IPowerStateRequestHandler() override = default;
 
     Result GetPowerStateRequestEventReadableHandle(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result GetAndClearPowerStateRequest(Out<bool> out_cleared, Out<u32> out_priority);
 
 private:
-    Core::System& m_system;
     PowerStateRequestManager& m_power_state_request_manager;
 };
 

src/core/hle/service/psc/time/service_manager.cpp

@@ -15,7 +15,7 @@ namespace Service::PSC::Time {
 
 ServiceManager::ServiceManager(Core::System& system_, std::shared_ptr<TimeManager> time,
                                ServerManager* server_manager)
-    : ServiceFramework{system_, "time:m"}, m_system{system}, m_time{std::move(time)},
+    : ServiceFramework{system_, "time:m"}, m_time{std::move(time)},
       m_server_manager{*server_manager},
       m_local_system_clock{m_time->m_standard_local_system_clock},
       m_user_system_clock{m_time->m_standard_user_system_clock},
@@ -26,7 +26,7 @@ ServiceManager::ServiceManager(Core::System& system_, std::shared_ptr<TimeManage
       m_local_system_context_writer{m_time->m_local_system_clock_context_writer},
       m_network_system_context_writer{m_time->m_network_system_clock_context_writer},
       m_ephemeral_system_context_writer{m_time->m_ephemeral_network_clock_context_writer},
-      m_local_operation{m_system}, m_network_operation{m_system}, m_ephemeral_operation{m_system} {
+      m_local_operation{system_}, m_network_operation{system_}, m_ephemeral_operation{system_} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0,   D<&ServiceManager::GetStaticServiceAsUser>, "GetStaticServiceAsUser"},
@@ -93,7 +93,7 @@ Result ServiceManager::SetupStandardSteadyClockCore(bool is_rtc_reset_detected,
     m_steady_clock.Initialize(clock_source_id, rtc_offset, internal_offset, test_offset,
                               is_rtc_reset_detected);
     auto time = m_steady_clock.GetRawTime();
-    auto ticks = m_system.CoreTiming().GetClockTicks();
+    auto ticks = system.CoreTiming().GetClockTicks();
     auto boot_time = time - ConvertToTimeSpan(ticks).count();
     m_shared_memory.SetSteadyClockTimePoint(clock_source_id, boot_time);
     m_steady_clock.SetContinuousAdjustment(clock_source_id, boot_time);
@@ -219,7 +219,7 @@ Result ServiceManager::SetStandardSteadyClockBaseTime(s64 base_time) {
 
     m_steady_clock.SetRtcOffset(base_time);
     auto time = m_steady_clock.GetRawTime();
-    auto ticks = m_system.CoreTiming().GetClockTicks();
+    auto ticks = system.CoreTiming().GetClockTicks();
     auto diff = time - ConvertToTimeSpan(ticks).count();
     m_shared_memory.UpdateBaseTime(diff);
     m_steady_clock.UpdateContinuousAdjustmentTime(diff);
@@ -241,7 +241,7 @@ Result ServiceManager::GetClosestAlarmUpdatedEvent(
 Result ServiceManager::CheckAndSignalAlarms() {
     LOG_DEBUG(Service_Time, "called.");
 
-    m_alarms.CheckAndSignal(m_system.Kernel());
+    m_alarms.CheckAndSignal(system.Kernel());
     R_SUCCEED();
 }
 
@@ -277,16 +277,16 @@ void ServiceManager::SetupSAndP() {
         m_is_s_and_p_setup = true;
         m_server_manager.RegisterNamedService(
             "time:s", std::make_shared<StaticService>(
-                          m_system, StaticServiceSetupInfo{0, 0, 1, 0, 0, 0}, m_time, "time:s"));
+                          system, StaticServiceSetupInfo{0, 0, 1, 0, 0, 0}, m_time, "time:s"));
         m_server_manager.RegisterNamedService("time:p",
                                               std::make_shared<IPowerStateRequestHandler>(
-                                                  m_system, m_time->m_power_state_request_manager));
+                                                  system, m_time->m_power_state_request_manager));
     }
 }
 
 Result ServiceManager::GetStaticService(OutInterface<StaticService> out_service,
                                         StaticServiceSetupInfo setup_info, const char* name) {
-    *out_service = std::make_shared<StaticService>(m_system, setup_info, m_time, name);
+    *out_service = std::make_shared<StaticService>(system, setup_info, m_time, name);
     R_SUCCEED();
 }
 

src/core/hle/service/psc/time/service_manager.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -60,10 +63,8 @@ public:
 private:
     void CheckAndSetupServicesSAndP();
     void SetupSAndP();
-    Result GetStaticService(OutInterface<StaticService> out_service,
-                            StaticServiceSetupInfo setup_info, const char* name);
+    Result GetStaticService(OutInterface<StaticService> out_service, StaticServiceSetupInfo setup_info, const char* name);
 
-    Core::System& m_system;
     std::shared_ptr<TimeManager> m_time;
     ServerManager& m_server_manager;
     bool m_is_s_and_p_setup{};

src/core/hle/service/psc/time/static.cpp

@@ -35,7 +35,7 @@ constexpr Result GetTimeFromTimePointAndContext(s64* out_time, SteadyClockTimePo
 
 StaticService::StaticService(Core::System& system_, StaticServiceSetupInfo setup_info,
                              std::shared_ptr<TimeManager> time, const char* name)
-    : ServiceFramework{system_, name}, m_system{system}, m_setup_info{setup_info}, m_time{time},
+    : ServiceFramework{system_, name}, m_setup_info{setup_info}, m_time{time},
       m_local_system_clock{m_time->m_standard_local_system_clock},
       m_user_system_clock{m_time->m_standard_user_system_clock},
       m_network_system_clock{m_time->m_standard_network_system_clock},
@@ -72,7 +72,7 @@ StaticService::StaticService(Core::System& system_, StaticServiceSetupInfo setup
 Result StaticService::GetStandardUserSystemClock(OutInterface<SystemClock> out_service) {
     LOG_DEBUG(Service_Time, "called.");
 
-    *out_service = std::make_shared<SystemClock>(m_system, m_user_system_clock,
+    *out_service = std::make_shared<SystemClock>(system, m_user_system_clock,
                                                  m_setup_info.can_write_user_clock,
                                                  m_setup_info.can_write_uninitialized_clock);
     R_SUCCEED();
@@ -81,7 +81,7 @@ Result StaticService::GetStandardUserSystemClock(OutInterface<SystemClock> out_s
 Result StaticService::GetStandardNetworkSystemClock(OutInterface<SystemClock> out_service) {
     LOG_DEBUG(Service_Time, "called.");
 
-    *out_service = std::make_shared<SystemClock>(m_system, m_network_system_clock,
+    *out_service = std::make_shared<SystemClock>(system, m_network_system_clock,
                                                  m_setup_info.can_write_network_clock,
                                                  m_setup_info.can_write_uninitialized_clock);
     R_SUCCEED();
@@ -91,7 +91,7 @@ Result StaticService::GetStandardSteadyClock(OutInterface<SteadyClock> out_servi
     LOG_DEBUG(Service_Time, "called.");
 
     *out_service =
-        std::make_shared<SteadyClock>(m_system, m_time, m_setup_info.can_write_steady_clock,
+        std::make_shared<SteadyClock>(system, m_time, m_setup_info.can_write_steady_clock,
                                       m_setup_info.can_write_uninitialized_clock);
     R_SUCCEED();
 }
@@ -100,7 +100,7 @@ Result StaticService::GetTimeZoneService(OutInterface<TimeZoneService> out_servi
     LOG_DEBUG(Service_Time, "called.");
 
     *out_service =
-        std::make_shared<TimeZoneService>(m_system, m_time->m_standard_steady_clock, m_time_zone,
+        std::make_shared<TimeZoneService>(system, m_time->m_standard_steady_clock, m_time_zone,
                                           m_setup_info.can_write_timezone_device_location);
     R_SUCCEED();
 }
@@ -108,7 +108,7 @@ Result StaticService::GetTimeZoneService(OutInterface<TimeZoneService> out_servi
 Result StaticService::GetStandardLocalSystemClock(OutInterface<SystemClock> out_service) {
     LOG_DEBUG(Service_Time, "called.");
 
-    *out_service = std::make_shared<SystemClock>(m_system, m_local_system_clock,
+    *out_service = std::make_shared<SystemClock>(system, m_local_system_clock,
                                                  m_setup_info.can_write_local_clock,
                                                  m_setup_info.can_write_uninitialized_clock);
     R_SUCCEED();
@@ -117,7 +117,7 @@ Result StaticService::GetStandardLocalSystemClock(OutInterface<SystemClock> out_
 Result StaticService::GetEphemeralNetworkSystemClock(OutInterface<SystemClock> out_service) {
     LOG_DEBUG(Service_Time, "called.");
 
-    *out_service = std::make_shared<SystemClock>(m_system, m_ephemeral_network_clock,
+    *out_service = std::make_shared<SystemClock>(system, m_ephemeral_network_clock,
                                                  m_setup_info.can_write_network_clock,
                                                  m_setup_info.can_write_uninitialized_clock);
     R_SUCCEED();
@@ -222,7 +222,7 @@ Result StaticService::CalculateMonotonicSystemClockBaseTimePoint(
 
     auto one_second_ns{
         std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::seconds(1)).count()};
-    auto ticks{m_system.CoreTiming().GetClockTicks()};
+    auto ticks{system.CoreTiming().GetClockTicks()};
     auto current_time_ns{ConvertToTimeSpan(ticks).count()};
     *out_time = ((context.offset + time_point.time_point) - (current_time_ns / one_second_ns));
 

src/core/hle/service/psc/time/static.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -68,8 +71,6 @@ private:
     Result GetClockSnapshotImpl(OutClockSnapshot out_snapshot,
                                 const SystemClockContext& user_context,
                                 const SystemClockContext& network_context, TimeType type);
-
-    Core::System& m_system;
     StaticServiceSetupInfo m_setup_info;
     std::shared_ptr<TimeManager> m_time;
     StandardLocalSystemClockCore& m_local_system_clock;

src/core/hle/service/psc/time/steady_clock.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -13,10 +13,11 @@ namespace Service::PSC::Time {
 
 SteadyClock::SteadyClock(Core::System& system_, std::shared_ptr<TimeManager> manager,
                          bool can_write_steady_clock, bool can_write_uninitialized_clock)
-    : ServiceFramework{system_, "ISteadyClock"}, m_system{system},
-      m_clock_core{manager->m_standard_steady_clock},
-      m_can_write_steady_clock{can_write_steady_clock}, m_can_write_uninitialized_clock{
-                                                            can_write_uninitialized_clock} {
+    : ServiceFramework{system_, "ISteadyClock"}
+    , m_clock_core{manager->m_standard_steady_clock}
+    , m_can_write_steady_clock{can_write_steady_clock}
+    , m_can_write_uninitialized_clock{can_write_uninitialized_clock}
+{
     // clang-format off
          static const FunctionInfo functions[] = {
         {0, D<&SteadyClock::GetCurrentTimePoint>, "GetCurrentTimePoint"},

src/core/hle/service/psc/time/steady_clock.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -32,8 +35,6 @@ public:
     Result GetInternalOffset(Out<s64> out_internal_offset);
 
 private:
-    Core::System& m_system;
-
     StandardSteadyClockCore& m_clock_core;
     bool m_can_write_steady_clock;
     bool m_can_write_uninitialized_clock;

src/core/hle/service/psc/time/system_clock.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -8,11 +11,12 @@
 
 namespace Service::PSC::Time {
 
-SystemClock::SystemClock(Core::System& system_, SystemClockCore& clock_core, bool can_write_clock,
-                         bool can_write_uninitialized_clock)
-    : ServiceFramework{system_, "ISystemClock"}, m_system{system}, m_clock_core{clock_core},
-      m_can_write_clock{can_write_clock}, m_can_write_uninitialized_clock{
-                                              can_write_uninitialized_clock} {
+SystemClock::SystemClock(Core::System& system_, SystemClockCore& clock_core, bool can_write_clock, bool can_write_uninitialized_clock)
+    : ServiceFramework{system_, "ISystemClock"}
+    , m_clock_core{clock_core}
+    , m_can_write_clock{can_write_clock}
+    , m_can_write_uninitialized_clock{can_write_uninitialized_clock}
+{
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, D<&SystemClock::GetCurrentTime>, "GetCurrentTime"},
@@ -72,7 +76,7 @@ Result SystemClock::GetOperationEventReadableHandle(
     LOG_DEBUG(Service_Time, "called.");
 
     if (!m_operation_event) {
-        m_operation_event = std::make_unique<OperationEvent>(m_system);
+        m_operation_event = std::make_unique<OperationEvent>(system);
         R_UNLESS(m_operation_event != nullptr, ResultFailed);
 
         m_clock_core.LinkOperationEvent(*m_operation_event);

src/core/hle/service/psc/time/system_clock.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -18,9 +21,7 @@ namespace Service::PSC::Time {
 
 class SystemClock final : public ServiceFramework<SystemClock> {
 public:
-    explicit SystemClock(Core::System& system, SystemClockCore& system_clock_core,
-                         bool can_write_clock, bool can_write_uninitialized_clock);
-
+    explicit SystemClock(Core::System& system, SystemClockCore& system_clock_core, bool can_write_clock, bool can_write_uninitialized_clock);
     ~SystemClock() override = default;
 
     Result GetCurrentTime(Out<s64> out_time);
@@ -30,8 +31,6 @@ public:
     Result GetOperationEventReadableHandle(OutCopyHandle<Kernel::KReadableEvent> out_event);
 
 private:
-    Core::System& m_system;
-
     SystemClockCore& m_clock_core;
     bool m_can_write_clock;
     bool m_can_write_uninitialized_clock;

src/core/hle/service/psc/time/time_zone_service.cpp

@@ -15,9 +15,11 @@ namespace Service::PSC::Time {
 
 TimeZoneService::TimeZoneService(Core::System& system_, StandardSteadyClockCore& clock_core,
                                  TimeZone& time_zone, bool can_write_timezone_device_location)
-    : ServiceFramework{system_, "ITimeZoneService"}, m_system{system}, m_clock_core{clock_core},
-      m_time_zone{time_zone}, m_can_write_timezone_device_location{
-                                  can_write_timezone_device_location} {
+    : ServiceFramework{system_, "ITimeZoneService"}
+    , m_clock_core{clock_core}
+    , m_time_zone{time_zone}
+    , m_can_write_timezone_device_location{can_write_timezone_device_location}
+{
     // clang-format off
     static const FunctionInfo functions[] = {
         {0,   D<&TimeZoneService::GetDeviceLocationName>, "GetDeviceLocationName"},

src/core/hle/service/psc/time/time_zone_service.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -56,8 +59,6 @@ public:
                                  const CalendarTime& calendar_time);
 
 private:
-    Core::System& m_system;
-
     StandardSteadyClockCore& m_clock_core;
     TimeZone& m_time_zone;
     bool m_can_write_timezone_device_location;