Replace Harmony with up-to-date RuntimeDetour

Dalamud/Dalamud.cs

@@ -2,6 +2,7 @@ using System;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Threading;
 
@@ -23,7 +24,7 @@ using Dalamud.Logging.Internal;
 using Dalamud.Plugin.Internal;
 using Dalamud.Plugin.Ipc.Internal;
 using Dalamud.Support;
-using HarmonyLib;
+using MonoMod.RuntimeDetour;
 using Serilog;
 using Serilog.Core;
 using Serilog.Events;
@@ -383,17 +384,20 @@ namespace Dalamud
         /// uses pseudo-handles to access memory, to prevent permission errors.
         /// It should never be called manually.
         /// </summary>
-        /// <param name="__instance">The equivalent of `this`.</param>
+        /// <param name="orig">A delegate that acts as the original method.</param>
-        /// <param name="__result">The result from the original method.</param>
+        /// <param name="self">The equivalent of `this`.</param>
-        [SuppressMessage("StyleCop.CSharp.NamingRules", "SA1313:Parameter names should begin with lower-case letter", Justification = "Enforced naming for special injected parameters")]
+        /// <returns>A pseudo-handle for the current process, or the result from the original method.</returns>
-        private static void ProcessHandlePatch(Process __instance, ref IntPtr __result)
+        private static IntPtr ProcessHandlePatch(Func<Process, IntPtr> orig, Process self)
         {
-            if (__instance.Id == Environment.ProcessId)
+            var result = orig(self);
+
+            if (self.Id == Environment.ProcessId)
             {
-                __result = (IntPtr)0xFFFFFFFF;
+                result = (IntPtr)0xFFFFFFFF;
             }
 
-            // Log.Verbose($"Process.Handle // {__instance.ProcessName} // {__result:X}");
+            // Log.Verbose($"Process.Handle // {self.ProcessName} // {result:X}");
+            return result;
         }
 
         private static void SerilogOnLogLine(object? sender, (string Line, LogEventLevel Level, DateTimeOffset TimeStamp, Exception? Exception) e)
@@ -406,13 +410,11 @@ namespace Dalamud
 
         private void ApplyProcessPatch()
         {
-            var harmony = new Harmony("goatcorp.dalamud");
-
             var targetType = typeof(Process);
 
-            var handleTarget = AccessTools.PropertyGetter(targetType, nameof(Process.Handle));
+            var handleTarget = targetType.GetProperty(nameof(Process.Handle)).GetGetMethod();
-            var handlePatch = AccessTools.Method(typeof(Dalamud), nameof(Dalamud.ProcessHandlePatch));
+            var handlePatch = typeof(Dalamud).GetMethod(nameof(Dalamud.ProcessHandlePatch), BindingFlags.NonPublic | BindingFlags.Static);
-            harmony.Patch(handleTarget, postfix: new(handlePatch));
+            _ = new Hook(handleTarget, handlePatch);
         }
     }
 }

Dalamud/Dalamud.csproj

@@ -65,10 +65,9 @@
     <ItemGroup>
         <PackageReference Include="CheapLoc" Version="1.1.6" />
         <PackageReference Include="JetBrains.Annotations" Version="2021.2.0" />
-        <PackageReference Include="Lib.Harmony" Version="2.1.1" />
         <PackageReference Include="Lumina" Version="3.3.0" />
         <PackageReference Include="Lumina.Excel" Version="5.50.0" />
-        <PackageReference Include="MonoMod.Common" Version="21.10.8.11" />
+        <PackageReference Include="MonoMod.RuntimeDetour" Version="21.10.10.01" />
         <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
         <PackageReference Include="Serilog" Version="2.10.0" />
         <PackageReference Include="Serilog.Sinks.Async" Version="1.5.0" />

Dalamud/Plugin/Internal/PluginManager.cs

@@ -20,7 +20,7 @@ using Dalamud.Logging.Internal;
 using Dalamud.Plugin.Internal.Exceptions;
 using Dalamud.Plugin.Internal.Types;
 using Dalamud.Utility;
-using HarmonyLib;
+using MonoMod.RuntimeDetour;
 using Newtonsoft.Json;
 
 namespace Dalamud.Plugin.Internal
@@ -1074,26 +1074,29 @@ namespace Dalamud.Plugin.Internal
         /// This patch facilitates resolving the assembly location for plugins that are loaded via byte[].
         /// It should never be called manually.
         /// </summary>
-        /// <param name="__instance">The equivalent of `this`.</param>
+        /// <param name="orig">A delegate that acts as the original method.</param>
-        /// <param name="__result">The result from the original method.</param>
+        /// <param name="self">The equivalent of `this`.</param>
-        [SuppressMessage("StyleCop.CSharp.NamingRules", "SA1313:Parameter names should begin with lower-case letter", Justification = "Enforced naming for special injected parameters")]
+        /// <returns>The plugin location, or the result from the original method.</returns>
-        private static void AssemblyLocationPatch(Assembly __instance, ref string __result)
+        private static string AssemblyLocationPatch(Func<Assembly, string?> orig, Assembly self)
         {
-            if (string.IsNullOrEmpty(__result))
+            var result = orig(self);
+
+            if (string.IsNullOrEmpty(result))
             {
                 foreach (var assemblyName in GetStackFrameAssemblyNames())
                 {
                     if (PluginLocations.TryGetValue(assemblyName, out var data))
                     {
-                        __result = data.Location;
+                        result = data.Location;
                         break;
                     }
                 }
             }
 
-            __result ??= string.Empty;
+            result ??= string.Empty;
 
-            Log.Verbose($"Assembly.Location // {__instance.FullName} // {__result}");
+            Log.Verbose($"Assembly.Location // {self.FullName} // {result}");
+            return result;
         }
 
         /// <summary>
@@ -1101,26 +1104,29 @@ namespace Dalamud.Plugin.Internal
         /// This patch facilitates resolving the assembly location for plugins that are loaded via byte[].
         /// It should never be called manually.
         /// </summary>
-        /// <param name="__instance">The equivalent of `this`.</param>
+        /// <param name="orig">A delegate that acts as the original method.</param>
-        /// <param name="__result">The result from the original method.</param>
+        /// <param name="self">The equivalent of `this`.</param>
-        [SuppressMessage("StyleCop.CSharp.NamingRules", "SA1313:Parameter names should begin with lower-case letter", Justification = "Enforced naming for special injected parameters")]
+        /// <returns>The plugin code base, or the result from the original method.</returns>
-        private static void AssemblyCodeBasePatch(Assembly __instance, ref string __result)
+        private static string AssemblyCodeBasePatch(Func<Assembly, string?> orig, Assembly self)
         {
-            if (string.IsNullOrEmpty(__result))
+            var result = orig(self);
+
+            if (string.IsNullOrEmpty(result))
             {
                 foreach (var assemblyName in GetStackFrameAssemblyNames())
                 {
                     if (PluginLocations.TryGetValue(assemblyName, out var data))
                     {
-                        __result = data.CodeBase;
+                        result = data.CodeBase;
                         break;
                     }
                 }
             }
 
-            __result ??= string.Empty;
+            result ??= string.Empty;
 
-            Log.Verbose($"Assembly.CodeBase // {__instance.FullName} // {__result}");
+            Log.Verbose($"Assembly.CodeBase // {self.FullName} // {result}");
+            return result;
         }
 
         private static IEnumerable<string> GetStackFrameAssemblyNames()
@@ -1140,18 +1146,16 @@ namespace Dalamud.Plugin.Internal
 
         private void ApplyPatches()
         {
-            var harmony = new Harmony("goatcorp.dalamud.pluginmanager");
-
             var targetType = typeof(PluginManager).Assembly.GetType();
 
-            var locationTarget = AccessTools.PropertyGetter(targetType, nameof(Assembly.Location));
+            var locationTarget = targetType.GetProperty(nameof(Assembly.Location)).GetGetMethod();
-            var locationPatch = AccessTools.Method(typeof(PluginManager), nameof(PluginManager.AssemblyLocationPatch));
+            var locationPatch = typeof(PluginManager).GetMethod(nameof(PluginManager.AssemblyLocationPatch), BindingFlags.NonPublic | BindingFlags.Static);
-            harmony.Patch(locationTarget, postfix: new(locationPatch));
+            _ = new Hook(locationTarget, locationPatch);
 
 #pragma warning disable SYSLIB0012 // Type or member is obsolete
-            var codebaseTarget = AccessTools.PropertyGetter(targetType, nameof(Assembly.CodeBase));
+            var codebaseTarget = targetType.GetProperty(nameof(Assembly.CodeBase)).GetGetMethod();
-            var codebasePatch = AccessTools.Method(typeof(PluginManager), nameof(PluginManager.AssemblyCodeBasePatch));
+            var codebasePatch = typeof(PluginManager).GetMethod(nameof(PluginManager.AssemblyCodeBasePatch), BindingFlags.NonPublic | BindingFlags.Static);
-            harmony.Patch(codebaseTarget, postfix: new(codebasePatch));
+            _ = new Hook(codebaseTarget, codebasePatch);
 #pragma warning restore SYSLIB0012 // Type or member is obsolete
         }