fix: register interfaces for provided services

Dalamud.CorePlugin/PluginImpl.cs

@@ -2,6 +2,7 @@ using System;
 using System.IO;
 
 using Dalamud.Configuration.Internal;
+using Dalamud.Game;
 using Dalamud.Game.Command;
 using Dalamud.Interface.Windowing;
 using Dalamud.Plugin;
@@ -55,7 +56,7 @@ namespace Dalamud.CorePlugin
         /// </summary>
         /// <param name="pluginInterface">Dalamud plugin interface.</param>
         /// <param name="log">Logging service.</param>
-        public PluginImpl(DalamudPluginInterface pluginInterface, IPluginLog log)
+        public PluginImpl(DalamudPluginInterface pluginInterface, IPluginLog log, ISigScanner scanner)
         {
             try
             {
@@ -65,6 +66,8 @@ namespace Dalamud.CorePlugin
 
                 this.windowSystem.AddWindow(new PluginWindow());
 
+                this.pluginLog.Information(scanner.ToString());
+
                 this.Interface.UiBuilder.Draw += this.OnDraw;
                 this.Interface.UiBuilder.OpenConfigUi += this.OnOpenConfigUi;
                 this.Interface.UiBuilder.OpenMainUi += this.OnOpenMainUi;

Dalamud.Injector/Hacks.cs

@@ -0,0 +1,20 @@
+using System;
+
+// ReSharper disable once CheckNamespace
+namespace Dalamud;
+
+// TODO: Get rid of this! Move StartInfo to another assembly, make this good
+
+/// <summary>
+/// Class to initialize Service&lt;T&gt;s.
+/// </summary>
+internal static class ServiceManager
+{
+    /// <summary>
+    /// Indicates that the class is a service.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class)]
+    public class Service : Attribute
+    {
+    }
+}

Dalamud/Configuration/Internal/DalamudConfiguration.cs

@@ -19,6 +19,7 @@ namespace Dalamud.Configuration.Internal;
 /// Class containing Dalamud settings.
 /// </summary>
 [Serializable]
+[ServiceManager.Service]
 internal sealed class DalamudConfiguration : IServiceType, IDisposable
 {
     private static readonly JsonSerializerSettings SerializerSettings = new()

Dalamud/Dalamud.cs

@@ -29,6 +29,7 @@ namespace Dalamud;
 /// <summary>
 /// The main Dalamud class containing all subsystems.
 /// </summary>
+[ServiceManager.Service]
 internal sealed class Dalamud : IServiceType
 {
     #region Internals

Dalamud/DalamudStartInfo.cs

@@ -10,6 +10,7 @@ namespace Dalamud;
 /// Struct containing information needed to initialize Dalamud.
 /// </summary>
 [Serializable]
+[ServiceManager.Service]
 public record DalamudStartInfo : IServiceType
 {
     /// <summary>

Dalamud/Game/TargetSigScanner.cs

@@ -11,6 +11,7 @@ namespace Dalamud.Game;
 /// </summary>
 [PluginInterface]
 [InterfaceVersion("1.0")]
+[ServiceManager.Service]
 #pragma warning disable SA1015
 [ResolveVia<ISigScanner>]
 #pragma warning restore SA1015

Dalamud/IoC/Internal/ServiceContainer.cs

@@ -16,6 +16,7 @@ namespace Dalamud.IoC.Internal;
 /// This is only used to resolve dependencies for plugins.
 /// Dalamud services are constructed via Service{T}.ConstructObject at the moment.
 /// </summary>
+[ServiceManager.Service]
 internal class ServiceContainer : IServiceProvider, IServiceType
 {
     private static readonly ModuleLog Log = new("SERVICECONTAINER");

Dalamud/ServiceManager.cs

@@ -92,28 +92,24 @@ internal static class ServiceManager
         var cacheDir = new DirectoryInfo(Path.Combine(startInfo.WorkingDirectory!, "cachedSigs"));
         if (!cacheDir.Exists)
             cacheDir.Create();
-
+        
         lock (LoadedServices)
         {
-            Service<Dalamud>.Provide(dalamud);
+            void ProvideService<T>(T service) where T : IServiceType
-            LoadedServices.Add(typeof(Dalamud));
+            {
-
+                Debug.Assert(typeof(T).GetServiceKind().HasFlag(ServiceKind.ManualService), "Provided service must have Service attribute");
-            Service<DalamudStartInfo>.Provide(startInfo);
+                Service<T>.Provide(service);
-            LoadedServices.Add(typeof(DalamudStartInfo));
+                LoadedServices.Add(typeof(T));
+            }
             
-            Service<ReliableFileStorage>.Provide(fs);
+            ProvideService(dalamud);
-            LoadedServices.Add(typeof(ReliableFileStorage));
+            ProvideService(startInfo);
-
+            ProvideService(fs);
-            Service<DalamudConfiguration>.Provide(configuration);
+            ProvideService(configuration);
-            LoadedServices.Add(typeof(DalamudConfiguration));
+            ProvideService(new ServiceContainer());
-
+            ProvideService(
-            Service<ServiceContainer>.Provide(new ServiceContainer());
-            LoadedServices.Add(typeof(ServiceContainer));
-
-            Service<TargetSigScanner>.Provide(
                 new TargetSigScanner(
-                    true, new FileInfo(Path.Combine(cacheDir.FullName, $"{startInfo.GameVersion}.json"))));
+                               true, new FileInfo(Path.Combine(cacheDir.FullName, $"{startInfo.GameVersion}.json"))));
-            LoadedServices.Add(typeof(TargetSigScanner));
         }
 
         using (Timings.Start("CS Resolver Init"))
@@ -149,7 +145,8 @@ internal static class ServiceManager
             serviceContainer.RegisterInterfaces(serviceType);
             
             // Scoped service do not go through Service<T> and are never early loaded
-            if (serviceKind.HasFlag(ServiceKind.ScopedService))
+            // Manual services are provided
+            if (serviceKind.HasFlag(ServiceKind.ScopedService) || serviceKind.HasFlag(ServiceKind.ManualService))
                 continue;
             
             Debug.Assert(

Dalamud/Storage/ReliableFileStorage.cs

@@ -23,6 +23,7 @@ namespace Dalamud.Storage;
 /// <remarks>
 /// This is not an early-loaded service, as it is needed before they are initialized.
 /// </remarks>
+[ServiceManager.Service]
 public class ReliableFileStorage : IServiceType, IDisposable
 {
     private static readonly ModuleLog Log = new("VFS");