rewrite assembly rewriting, merge Harmony rewriters (#711)

This reduces duplication, decouples it from the assembly loader, and makes it more flexible to handle Harmony rewriting.

21 files changed, 699 insertions, 702 deletions

diff --git a/src/SMAPI/Framework/ModLoading/AssemblyLoader.cs b/src/SMAPI/Framework/ModLoading/AssemblyLoader.cs
index b95a45b5..d9b4af1b 100644
--- a/src/SMAPI/Framework/ModLoading/AssemblyLoader.cs
+++ b/src/SMAPI/Framework/ModLoading/AssemblyLoader.cs
@@ -4,8 +4,8 @@ using System.IO;
 using System.Linq;
 using System.Reflection;
 using Mono.Cecil;
-using Mono.Cecil.Cil;
 using StardewModdingAPI.Framework.Exceptions;
+using StardewModdingAPI.Framework.ModLoading.Framework;
 using StardewModdingAPI.Metadata;
 using StardewModdingAPI.Toolkit.Framework.ModData;
 using StardewModdingAPI.Toolkit.Utilities;
@@ -283,54 +283,32 @@ namespace StardewModdingAPI.Framework.ModLoading
                     this.ChangeTypeScope(type);
             }
 
-            // find (and optionally rewrite) incompatible instructions
-            bool anyRewritten = false;
-            IInstructionHandler[] handlers = new InstructionMetadata().GetHandlers(this.ParanoidMode).ToArray();
-            foreach (TypeDefinition type in module.GetTypes())
-            {
-                // check type definition
-                foreach (IInstructionHandler handler in handlers)
+            // find or rewrite code
+            IInstructionHandler[] handlers = new InstructionMetadata().GetHandlers(this.ParanoidMode, platformChanged).ToArray();
+            RecursiveRewriter rewriter = new RecursiveRewriter(
+                module: module,
+                rewriteType: (type, replaceWith) =>
                 {
-                    InstructionHandleResult result = handler.Handle(module, type, this.AssemblyMap, platformChanged);
-                    this.ProcessInstructionHandleResult(mod, handler, result, loggedMessages, logPrefix, filename);
-                    if (result == InstructionHandleResult.Rewritten)
-                        anyRewritten = true;
-                }
-
-                // check methods
-                foreach (MethodDefinition method in type.Methods.Where(p => p.HasBody))
+                    bool rewritten = false;
+                    foreach (IInstructionHandler handler in handlers)
+                        rewritten |= handler.Handle(module, type, replaceWith);
+                    return rewritten;
+                },
+                rewriteInstruction: (instruction, cil, replaceWith) =>
                 {
-                    // check method definition
+                    bool rewritten = false;
                     foreach (IInstructionHandler handler in handlers)
-                    {
-                        InstructionHandleResult result = handler.Handle(module, method, this.AssemblyMap, platformChanged);
-                        this.ProcessInstructionHandleResult(mod, handler, result, loggedMessages, logPrefix, filename);
-                        if (result == InstructionHandleResult.Rewritten)
-                            anyRewritten = true;
-                    }
-
-                    // check CIL instructions
-                    ILProcessor cil = method.Body.GetILProcessor();
-                    var instructions = cil.Body.Instructions;
-                    // ReSharper disable once ForCanBeConvertedToForeach -- deliberate access by index so each handler sees replacements from previous handlers
-                    for (int offset = 0; offset < instructions.Count; offset++)
-                    {
-                        Instruction instruction = instructions[offset];
-                        if (instruction.OpCode.Code == Code.Nop)
-                            continue;
-
-                        foreach (IInstructionHandler handler in handlers)
-                        {
-                            InstructionHandleResult result = handler.Handle(module, cil, instruction, this.AssemblyMap, platformChanged);
-                            this.ProcessInstructionHandleResult(mod, handler, result, loggedMessages, logPrefix, filename);
-                            if (result == InstructionHandleResult.Rewritten)
-                            {
-                                instruction = instructions[offset];
-                                anyRewritten = true;
-                            }
-                        }
-                    }
+                        rewritten |= handler.Handle(module, cil, instruction, replaceWith);
+                    return rewritten;
                 }
+            );
+            bool anyRewritten = rewriter.RewriteModule();
+
+            // handle rewrite flags
+            foreach (IInstructionHandler handler in handlers)
+            {
+                foreach (var flag in handler.Flags)
+                    this.ProcessInstructionHandleResult(mod, handler, flag, loggedMessages, logPrefix, filename);
             }
 
             return platformChanged || anyRewritten;
@@ -345,49 +323,52 @@ namespace StardewModdingAPI.Framework.ModLoading
         /// <param name="filename">The assembly filename for log messages.</param>
         private void ProcessInstructionHandleResult(IModMetadata mod, IInstructionHandler handler, InstructionHandleResult result, HashSet<string> loggedMessages, string logPrefix, string filename)
         {
+            // get message template
+            // ($phrase is replaced with the noun phrase or messages)
+            string template = null;
             switch (result)
             {
                 case InstructionHandleResult.Rewritten:
-                    this.Monitor.LogOnce(loggedMessages, $"{logPrefix}Rewrote {filename} to fix {handler.NounPhrase}...");
+                    template = $"{logPrefix}Rewrote {filename} to fix $phrase...";
                     break;
 
                 case InstructionHandleResult.NotCompatible:
-                    this.Monitor.LogOnce(loggedMessages, $"{logPrefix}Broken code in {filename}: {handler.NounPhrase}.");
+                    template = $"{logPrefix}Broken code in {filename}: $phrase.";
                     mod.SetWarning(ModWarning.BrokenCodeLoaded);
                     break;
 
                 case InstructionHandleResult.DetectedGamePatch:
-                    this.Monitor.LogOnce(loggedMessages, $"{logPrefix}Detected game patcher ({handler.NounPhrase}) in assembly {filename}.");
+                    template = $"{logPrefix}Detected game patcher ($phrase) in assembly {filename}.";
                     mod.SetWarning(ModWarning.PatchesGame);
                     break;
 
                 case InstructionHandleResult.DetectedSaveSerializer:
-                    this.Monitor.LogOnce(loggedMessages, $"{logPrefix}Detected possible save serializer change ({handler.NounPhrase}) in assembly {filename}.");
+                    template = $"{logPrefix}Detected possible save serializer change ($phrase) in assembly {filename}.";
                     mod.SetWarning(ModWarning.ChangesSaveSerializer);
                     break;
 
                 case InstructionHandleResult.DetectedUnvalidatedUpdateTick:
-                    this.Monitor.LogOnce(loggedMessages, $"{logPrefix}Detected reference to {handler.NounPhrase} in assembly {filename}.");
+                    template = $"{logPrefix}Detected reference to $phrase in assembly {filename}.";
                     mod.SetWarning(ModWarning.UsesUnvalidatedUpdateTick);
                     break;
 
                 case InstructionHandleResult.DetectedDynamic:
-                    this.Monitor.LogOnce(loggedMessages, $"{logPrefix}Detected 'dynamic' keyword ({handler.NounPhrase}) in assembly {filename}.");
+                    template = $"{logPrefix}Detected 'dynamic' keyword ($phrase) in assembly {filename}.";
                     mod.SetWarning(ModWarning.UsesDynamic);
                     break;
 
                 case InstructionHandleResult.DetectedConsoleAccess:
-                    this.Monitor.LogOnce(loggedMessages, $"{logPrefix}Detected direct console access ({handler.NounPhrase}) in assembly {filename}.");
+                    template = $"{logPrefix}Detected direct console access ($phrase) in assembly {filename}.";
                     mod.SetWarning(ModWarning.AccessesConsole);
                     break;
 
                 case InstructionHandleResult.DetectedFilesystemAccess:
-                    this.Monitor.LogOnce(loggedMessages, $"{logPrefix}Detected filesystem access ({handler.NounPhrase}) in assembly {filename}.");
+                    template = $"{logPrefix}Detected filesystem access ($phrase) in assembly {filename}.";
                     mod.SetWarning(ModWarning.AccessesFilesystem);
                     break;
 
                 case InstructionHandleResult.DetectedShellAccess:
-                    this.Monitor.LogOnce(loggedMessages, $"{logPrefix}Detected shell or process access ({handler.NounPhrase}) in assembly {filename}.");
+                    template = $"{logPrefix}Detected shell or process access ($phrase) in assembly {filename}.";
                     mod.SetWarning(ModWarning.AccessesShell);
                     break;
 
@@ -397,6 +378,17 @@ namespace StardewModdingAPI.Framework.ModLoading
                 default:
                     throw new NotSupportedException($"Unrecognized instruction handler result '{result}'.");
             }
+            if (template == null)
+                return;
+
+            // format messages
+            if (handler.Phrases.Any())
+            {
+                foreach (string message in handler.Phrases)
+                    this.Monitor.LogOnce(template.Replace("$phrase", message));
+            }
+            else
+                this.Monitor.LogOnce(template.Replace("$phrase", handler.DefaultPhrase ?? handler.GetType().Name));
         }
 
         /// <summary>Get the correct reference to use for compatibility with the current platform.</summary>
diff --git a/src/SMAPI/Framework/ModLoading/Finders/EventFinder.cs b/src/SMAPI/Framework/ModLoading/Finders/EventFinder.cs
index 1a7ae636..e1476b73 100644
--- a/src/SMAPI/Framework/ModLoading/Finders/EventFinder.cs
+++ b/src/SMAPI/Framework/ModLoading/Finders/EventFinder.cs
@@ -1,3 +1,4 @@
+using System;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 using StardewModdingAPI.Framework.ModLoading.Framework;
@@ -28,24 +29,25 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
         /// <param name="eventName">The event name for which to find references.</param>
         /// <param name="result">The result to return for matching instructions.</param>
         public EventFinder(string fullTypeName, string eventName, InstructionHandleResult result)
-            : base(nounPhrase: $"{fullTypeName}.{eventName} event")
+            : base(defaultPhrase: $"{fullTypeName}.{eventName} event")
         {
             this.FullTypeName = fullTypeName;
             this.EventName = eventName;
             this.Result = result;
         }
 
-        /// <summary>Perform the predefined logic for an instruction if applicable.</summary>
+        /// <summary>Rewrite a CIL instruction reference if needed.</summary>
         /// <param name="module">The assembly module containing the instruction.</param>
         /// <param name="cil">The CIL processor.</param>
         /// <param name="instruction">The CIL instruction to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        /// <param name="replaceWith">Replaces the CIL instruction with a new one.</param>
+        /// <returns>Returns whether the instruction was changed.</returns>
+        public override bool Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, Action<Instruction> replaceWith)
         {
-            return this.IsMatch(instruction)
-                ? this.Result
-                : InstructionHandleResult.None;
+            if (!this.Flags.Contains(this.Result) && this.IsMatch(instruction))
+                this.MarkFlag(this.Result);
+
+            return false;
         }
 
 
diff --git a/src/SMAPI/Framework/ModLoading/Finders/FieldFinder.cs b/src/SMAPI/Framework/ModLoading/Finders/FieldFinder.cs
index 9ae07916..c157ed9b 100644
--- a/src/SMAPI/Framework/ModLoading/Finders/FieldFinder.cs
+++ b/src/SMAPI/Framework/ModLoading/Finders/FieldFinder.cs
@@ -1,3 +1,4 @@
+using System;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 using StardewModdingAPI.Framework.ModLoading.Framework;
@@ -28,39 +29,25 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
         /// <param name="fieldName">The field name for which to find references.</param>
         /// <param name="result">The result to return for matching instructions.</param>
         public FieldFinder(string fullTypeName, string fieldName, InstructionHandleResult result)
-            : base(nounPhrase: $"{fullTypeName}.{fieldName} field")
+            : base(defaultPhrase: $"{fullTypeName}.{fieldName} field")
         {
             this.FullTypeName = fullTypeName;
             this.FieldName = fieldName;
             this.Result = result;
         }
 
-        /// <summary>Perform the predefined logic for an instruction if applicable.</summary>
+        /// <summary>Rewrite a CIL instruction reference if needed.</summary>
         /// <param name="module">The assembly module containing the instruction.</param>
         /// <param name="cil">The CIL processor.</param>
         /// <param name="instruction">The CIL instruction to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        /// <param name="replaceWith">Replaces the CIL instruction with a new one.</param>
+        /// <returns>Returns whether the instruction was changed.</returns>
+        public override bool Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, Action<Instruction> replaceWith)
         {
-            return this.IsMatch(instruction)
-                ? this.Result
-                : InstructionHandleResult.None;
-        }
-
+            if (!this.Flags.Contains(this.Result) && RewriteHelper.IsFieldReferenceTo(instruction, this.FullTypeName, this.FieldName))
+                this.MarkFlag(this.Result);
 
-        /*********
-        ** Protected methods
-        *********/
-        /// <summary>Get whether a CIL instruction matches.</summary>
-        /// <param name="instruction">The IL instruction.</param>
-        protected bool IsMatch(Instruction instruction)
-        {
-            FieldReference fieldRef = RewriteHelper.AsFieldReference(instruction);
-            return
-                fieldRef != null
-                && fieldRef.DeclaringType.FullName == this.FullTypeName
-                && fieldRef.Name == this.FieldName;
+            return false;
         }
     }
 }
diff --git a/src/SMAPI/Framework/ModLoading/Finders/MethodFinder.cs b/src/SMAPI/Framework/ModLoading/Finders/MethodFinder.cs
index 75584f1f..82c93a7c 100644
--- a/src/SMAPI/Framework/ModLoading/Finders/MethodFinder.cs
+++ b/src/SMAPI/Framework/ModLoading/Finders/MethodFinder.cs
@@ -1,3 +1,4 @@
+using System;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 using StardewModdingAPI.Framework.ModLoading.Framework;
@@ -28,24 +29,25 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
         /// <param name="methodName">The method name for which to find references.</param>
         /// <param name="result">The result to return for matching instructions.</param>
         public MethodFinder(string fullTypeName, string methodName, InstructionHandleResult result)
-            : base(nounPhrase: $"{fullTypeName}.{methodName} method")
+            : base(defaultPhrase: $"{fullTypeName}.{methodName} method")
         {
             this.FullTypeName = fullTypeName;
             this.MethodName = methodName;
             this.Result = result;
         }
 
-        /// <summary>Perform the predefined logic for an instruction if applicable.</summary>
+        /// <summary>Rewrite a CIL instruction reference if needed.</summary>
         /// <param name="module">The assembly module containing the instruction.</param>
         /// <param name="cil">The CIL processor.</param>
         /// <param name="instruction">The CIL instruction to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        /// <param name="replaceWith">Replaces the CIL instruction with a new one.</param>
+        /// <returns>Returns whether the instruction was changed.</returns>
+        public override bool Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, Action<Instruction> replaceWith)
         {
-            return this.IsMatch(instruction)
-                ? this.Result
-                : InstructionHandleResult.None;
+            if (!this.Flags.Contains(this.Result) && this.IsMatch(instruction))
+                this.MarkFlag(this.Result);
+
+            return false;
         }
 
 
diff --git a/src/SMAPI/Framework/ModLoading/Finders/PropertyFinder.cs b/src/SMAPI/Framework/ModLoading/Finders/PropertyFinder.cs
index 811420c5..c96d61a2 100644
--- a/src/SMAPI/Framework/ModLoading/Finders/PropertyFinder.cs
+++ b/src/SMAPI/Framework/ModLoading/Finders/PropertyFinder.cs
@@ -1,3 +1,4 @@
+using System;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 using StardewModdingAPI.Framework.ModLoading.Framework;
@@ -28,24 +29,25 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
         /// <param name="propertyName">The property name for which to find references.</param>
         /// <param name="result">The result to return for matching instructions.</param>
         public PropertyFinder(string fullTypeName, string propertyName, InstructionHandleResult result)
-            : base(nounPhrase: $"{fullTypeName}.{propertyName} property")
+            : base(defaultPhrase: $"{fullTypeName}.{propertyName} property")
         {
             this.FullTypeName = fullTypeName;
             this.PropertyName = propertyName;
             this.Result = result;
         }
 
-        /// <summary>Perform the predefined logic for an instruction if applicable.</summary>
+        /// <summary>Rewrite a CIL instruction reference if needed.</summary>
         /// <param name="module">The assembly module containing the instruction.</param>
         /// <param name="cil">The CIL processor.</param>
         /// <param name="instruction">The CIL instruction to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        /// <param name="replaceWith">Replaces the CIL instruction with a new one.</param>
+        /// <returns>Returns whether the instruction was changed.</returns>
+        public override bool Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, Action<Instruction> replaceWith)
         {
-            return this.IsMatch(instruction)
-                ? this.Result
-                : InstructionHandleResult.None;
+            if (!this.Flags.Contains(this.Result) && this.IsMatch(instruction))
+                this.MarkFlag(this.Result);
+
+            return false;
         }
 
 
diff --git a/src/SMAPI/Framework/ModLoading/Finders/ReferenceToMemberWithUnexpectedTypeFinder.cs b/src/SMAPI/Framework/ModLoading/Finders/ReferenceToMemberWithUnexpectedTypeFinder.cs
index 1029d350..a67cfa4f 100644
--- a/src/SMAPI/Framework/ModLoading/Finders/ReferenceToMemberWithUnexpectedTypeFinder.cs
+++ b/src/SMAPI/Framework/ModLoading/Finders/ReferenceToMemberWithUnexpectedTypeFinder.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Mono.Cecil;
@@ -23,18 +24,18 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
         /// <summary>Construct an instance.</summary>
         /// <param name="validateReferencesToAssemblies">The assembly names to which to heuristically detect broken references.</param>
         public ReferenceToMemberWithUnexpectedTypeFinder(string[] validateReferencesToAssemblies)
-            : base(nounPhrase: "")
+            : base(defaultPhrase: "")
         {
             this.ValidateReferencesToAssemblies = new HashSet<string>(validateReferencesToAssemblies);
         }
 
-        /// <summary>Perform the predefined logic for an instruction if applicable.</summary>
+        /// <summary>Rewrite a CIL instruction reference if needed.</summary>
         /// <param name="module">The assembly module containing the instruction.</param>
         /// <param name="cil">The CIL processor.</param>
         /// <param name="instruction">The CIL instruction to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        /// <param name="replaceWith">Replaces the CIL instruction with a new one.</param>
+        /// <returns>Returns whether the instruction was changed.</returns>
+        public override bool Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, Action<Instruction> replaceWith)
         {
             // field reference
             FieldReference fieldRef = RewriteHelper.AsFieldReference(instruction);
@@ -43,13 +44,13 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
                 // get target field
                 FieldDefinition targetField = fieldRef.DeclaringType.Resolve()?.Fields.FirstOrDefault(p => p.Name == fieldRef.Name);
                 if (targetField == null)
-                    return InstructionHandleResult.None;
+                    return false;
 
                 // validate return type
                 if (!RewriteHelper.LooksLikeSameType(fieldRef.FieldType, targetField.FieldType))
                 {
-                    this.NounPhrase = $"reference to {fieldRef.DeclaringType.FullName}.{fieldRef.Name} (field returns {this.GetFriendlyTypeName(targetField.FieldType)}, not {this.GetFriendlyTypeName(fieldRef.FieldType)})";
-                    return InstructionHandleResult.NotCompatible;
+                    this.MarkFlag(InstructionHandleResult.NotCompatible, $"reference to {fieldRef.DeclaringType.FullName}.{fieldRef.Name} (field returns {this.GetFriendlyTypeName(targetField.FieldType)}, not {this.GetFriendlyTypeName(fieldRef.FieldType)})");
+                    return false;
                 }
             }
 
@@ -60,21 +61,21 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
                 // get potential targets
                 MethodDefinition[] candidateMethods = methodReference.DeclaringType.Resolve()?.Methods.Where(found => found.Name == methodReference.Name).ToArray();
                 if (candidateMethods == null || !candidateMethods.Any())
-                    return InstructionHandleResult.None;
+                    return false;
 
                 // compare return types
                 MethodDefinition methodDef = methodReference.Resolve();
                 if (methodDef == null)
-                    return InstructionHandleResult.None; // validated by ReferenceToMissingMemberFinder
+                    return false; // validated by ReferenceToMissingMemberFinder
 
                 if (candidateMethods.All(method => !RewriteHelper.LooksLikeSameType(method.ReturnType, methodDef.ReturnType)))
                 {
-                    this.NounPhrase = $"reference to {methodDef.DeclaringType.FullName}.{methodDef.Name} (no such method returns {this.GetFriendlyTypeName(methodDef.ReturnType)})";
-                    return InstructionHandleResult.NotCompatible;
+                    this.MarkFlag(InstructionHandleResult.NotCompatible, $"reference to {methodDef.DeclaringType.FullName}.{methodDef.Name} (no such method returns {this.GetFriendlyTypeName(methodDef.ReturnType)})");
+                    return false;
                 }
             }
 
-            return InstructionHandleResult.None;
+            return false;
         }
 
 
diff --git a/src/SMAPI/Framework/ModLoading/Finders/ReferenceToMissingMemberFinder.cs b/src/SMAPI/Framework/ModLoading/Finders/ReferenceToMissingMemberFinder.cs
index fefa88f4..ebb62948 100644
--- a/src/SMAPI/Framework/ModLoading/Finders/ReferenceToMissingMemberFinder.cs
+++ b/src/SMAPI/Framework/ModLoading/Finders/ReferenceToMissingMemberFinder.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Mono.Cecil;
@@ -23,18 +24,18 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
         /// <summary>Construct an instance.</summary>
         /// <param name="validateReferencesToAssemblies">The assembly names to which to heuristically detect broken references.</param>
         public ReferenceToMissingMemberFinder(string[] validateReferencesToAssemblies)
-            : base(nounPhrase: "")
+            : base(defaultPhrase: "")
         {
             this.ValidateReferencesToAssemblies = new HashSet<string>(validateReferencesToAssemblies);
         }
 
-        /// <summary>Perform the predefined logic for an instruction if applicable.</summary>
+        /// <summary>Rewrite a CIL instruction reference if needed.</summary>
         /// <param name="module">The assembly module containing the instruction.</param>
         /// <param name="cil">The CIL processor.</param>
         /// <param name="instruction">The CIL instruction to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        /// <param name="replaceWith">Replaces the CIL instruction with a new one.</param>
+        /// <returns>Returns whether the instruction was changed.</returns>
+        public override bool Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, Action<Instruction> replaceWith)
         {
             // field reference
             FieldReference fieldRef = RewriteHelper.AsFieldReference(instruction);
@@ -43,8 +44,8 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
                 FieldDefinition target = fieldRef.DeclaringType.Resolve()?.Fields.FirstOrDefault(p => p.Name == fieldRef.Name);
                 if (target == null)
                 {
-                    this.NounPhrase = $"reference to {fieldRef.DeclaringType.FullName}.{fieldRef.Name} (no such field)";
-                    return InstructionHandleResult.NotCompatible;
+                    this.MarkFlag(InstructionHandleResult.NotCompatible, $"reference to {fieldRef.DeclaringType.FullName}.{fieldRef.Name} (no such field)");
+                    return false;
                 }
             }
 
@@ -55,17 +56,20 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
                 MethodDefinition target = methodRef.Resolve();
                 if (target == null)
                 {
+                    string phrase = null;
                     if (this.IsProperty(methodRef))
-                        this.NounPhrase = $"reference to {methodRef.DeclaringType.FullName}.{methodRef.Name.Substring(4)} (no such property)";
+                        phrase = $"reference to {methodRef.DeclaringType.FullName}.{methodRef.Name.Substring(4)} (no such property)";
                     else if (methodRef.Name == ".ctor")
-                        this.NounPhrase = $"reference to {methodRef.DeclaringType.FullName}.{methodRef.Name} (no matching constructor)";
+                        phrase = $"reference to {methodRef.DeclaringType.FullName}.{methodRef.Name} (no matching constructor)";
                     else
-                        this.NounPhrase = $"reference to {methodRef.DeclaringType.FullName}.{methodRef.Name} (no such method)";
-                    return InstructionHandleResult.NotCompatible;
+                        phrase = $"reference to {methodRef.DeclaringType.FullName}.{methodRef.Name} (no such method)";
+
+                    this.MarkFlag(InstructionHandleResult.NotCompatible, phrase);
+                    return false;
                 }
             }
 
-            return InstructionHandleResult.None;
+            return false;
         }
 
 
diff --git a/src/SMAPI/Framework/ModLoading/Finders/TypeAssemblyFinder.cs b/src/SMAPI/Framework/ModLoading/Finders/TypeAssemblyFinder.cs
index 5301186b..a1ade536 100644
--- a/src/SMAPI/Framework/ModLoading/Finders/TypeAssemblyFinder.cs
+++ b/src/SMAPI/Framework/ModLoading/Finders/TypeAssemblyFinder.cs
@@ -5,21 +5,47 @@ using StardewModdingAPI.Framework.ModLoading.Framework;
 namespace StardewModdingAPI.Framework.ModLoading.Finders
 {
     /// <summary>Finds incompatible CIL instructions that reference types in a given assembly.</summary>
-    internal class TypeAssemblyFinder : BaseTypeFinder
+    internal class TypeAssemblyFinder : BaseInstructionHandler
     {
         /*********
+        ** Fields
+        *********/
+        /// <summary>The full assembly name to which to find references.</summary>
+        private readonly string AssemblyName;
+
+        /// <summary>The result to return for matching instructions.</summary>
+        private readonly InstructionHandleResult Result;
+
+        /// <summary>Get whether a matched type should be ignored.</summary>
+        private readonly Func<TypeReference, bool> ShouldIgnore;
+
+
+        /*********
         ** Public methods
         *********/
         /// <summary>Construct an instance.</summary>
         /// <param name="assemblyName">The full assembly name to which to find references.</param>
         /// <param name="result">The result to return for matching instructions.</param>
-        /// <param name="shouldIgnore">A lambda which overrides a matched type.</param>
+        /// <param name="shouldIgnore">Get whether a matched type should be ignored.</param>
         public TypeAssemblyFinder(string assemblyName, InstructionHandleResult result, Func<TypeReference, bool> shouldIgnore = null)
-            : base(
-                isMatch: type => type.Scope.Name == assemblyName && (shouldIgnore == null || !shouldIgnore(type)),
-                result: result,
-                nounPhrase: $"{assemblyName} assembly"
-            )
-        { }
+            : base(defaultPhrase: $"{assemblyName} assembly")
+        {
+            this.AssemblyName = assemblyName;
+            this.Result = result;
+            this.ShouldIgnore = shouldIgnore;
+        }
+
+        /// <summary>Rewrite a type reference if needed.</summary>
+        /// <param name="module">The assembly module containing the instruction.</param>
+        /// <param name="type">The type definition to handle.</param>
+        /// <param name="replaceWith">Replaces the type reference with a new one.</param>
+        /// <returns>Returns whether the type was changed.</returns>
+        public override bool Handle(ModuleDefinition module, TypeReference type, Action<TypeReference> replaceWith)
+        {
+            if (type.Scope.Name == this.AssemblyName && this.ShouldIgnore?.Invoke(type) != true)
+                this.MarkFlag(this.Result);
+
+            return false;
+        }
     }
 }
diff --git a/src/SMAPI/Framework/ModLoading/Finders/TypeFinder.cs b/src/SMAPI/Framework/ModLoading/Finders/TypeFinder.cs
index 3adc31c7..c285414a 100644
--- a/src/SMAPI/Framework/ModLoading/Finders/TypeFinder.cs
+++ b/src/SMAPI/Framework/ModLoading/Finders/TypeFinder.cs
@@ -5,21 +5,47 @@ using StardewModdingAPI.Framework.ModLoading.Framework;
 namespace StardewModdingAPI.Framework.ModLoading.Finders
 {
     /// <summary>Finds incompatible CIL instructions that reference a given type.</summary>
-    internal class TypeFinder : BaseTypeFinder
+    internal class TypeFinder : BaseInstructionHandler
     {
         /*********
+        ** Fields
+        *********/
+        /// <summary>The full type name to match.</summary>
+        private readonly string FullTypeName;
+
+        /// <summary>The result to return for matching instructions.</summary>
+        private readonly InstructionHandleResult Result;
+
+        /// <summary>Get whether a matched type should be ignored.</summary>
+        private readonly Func<TypeReference, bool> ShouldIgnore;
+
+
+        /*********
         ** Public methods
         *********/
         /// <summary>Construct an instance.</summary>
         /// <param name="fullTypeName">The full type name to match.</param>
         /// <param name="result">The result to return for matching instructions.</param>
-        /// <param name="shouldIgnore">A lambda which overrides a matched type.</param>
+        /// <param name="shouldIgnore">Get whether a matched type should be ignored.</param>
         public TypeFinder(string fullTypeName, InstructionHandleResult result, Func<TypeReference, bool> shouldIgnore = null)
-            : base(
-                isMatch: type => type.FullName == fullTypeName && (shouldIgnore == null || !shouldIgnore(type)),
-                result: result,
-                nounPhrase: $"{fullTypeName} type"
-            )
-        { }
+            : base(defaultPhrase: $"{fullTypeName} type")
+        {
+            this.FullTypeName = fullTypeName;
+            this.Result = result;
+            this.ShouldIgnore = shouldIgnore;
+        }
+
+        /// <summary>Rewrite a type reference if needed.</summary>
+        /// <param name="module">The assembly module containing the instruction.</param>
+        /// <param name="type">The type definition to handle.</param>
+        /// <param name="replaceWith">Replaces the type reference with a new one.</param>
+        /// <returns>Returns whether the type was changed.</returns>
+        public override bool Handle(ModuleDefinition module, TypeReference type, Action<TypeReference> replaceWith)
+        {
+            if (type.FullName == this.FullTypeName && this.ShouldIgnore?.Invoke(type) != true)
+                this.MarkFlag(this.Result);
+
+            return false;
+        }
     }
 }
diff --git a/src/SMAPI/Framework/ModLoading/Framework/BaseInstructionHandler.cs b/src/SMAPI/Framework/ModLoading/Framework/BaseInstructionHandler.cs
index 353de464..79fb45b8 100644
--- a/src/SMAPI/Framework/ModLoading/Framework/BaseInstructionHandler.cs
+++ b/src/SMAPI/Framework/ModLoading/Framework/BaseInstructionHandler.cs
@@ -1,3 +1,5 @@
+using System;
+using System.Collections.Generic;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 
@@ -9,42 +11,38 @@ namespace StardewModdingAPI.Framework.ModLoading.Framework
         /*********
         ** Accessors
         *********/
-        /// <summary>A brief noun phrase indicating what the handler matches.</summary>
-        public string NounPhrase { get; protected set; }
+        /// <summary>A brief noun phrase indicating what the handler matches, used if <see cref="Phrases"/> is empty.</summary>
+        public string DefaultPhrase { get; }
+
+        /// <summary>The rewrite flags raised for the current module.</summary>
+        public ISet<InstructionHandleResult> Flags { get; } = new HashSet<InstructionHandleResult>();
+
+        /// <summary>The brief noun phrases indicating what the handler matched for the current module.</summary>
+        public ISet<string> Phrases { get; } = new HashSet<string>(StringComparer.InvariantCultureIgnoreCase);
 
 
         /*********
         ** Public methods
         *********/
-        /// <summary>Perform the predefined logic for a method if applicable.</summary>
+        /// <summary>Rewrite a type reference if needed.</summary>
         /// <param name="module">The assembly module containing the instruction.</param>
         /// <param name="type">The type definition to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        public virtual InstructionHandleResult Handle(ModuleDefinition module, TypeDefinition type, PlatformAssemblyMap assemblyMap, bool platformChanged)
-        {
-            return InstructionHandleResult.None;
-        }
-
-        /// <summary>Perform the predefined logic for a method if applicable.</summary>
-        /// <param name="module">The assembly module containing the instruction.</param>
-        /// <param name="method">The method definition to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        public virtual InstructionHandleResult Handle(ModuleDefinition module, MethodDefinition method, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        /// <param name="replaceWith">Replaces the type reference with a new one.</param>
+        /// <returns>Returns whether the type was changed.</returns>
+        public virtual bool Handle(ModuleDefinition module, TypeReference type, Action<TypeReference> replaceWith)
         {
-            return InstructionHandleResult.None;
+            return false;
         }
 
-        /// <summary>Perform the predefined logic for an instruction if applicable.</summary>
+        /// <summary>Rewrite a CIL instruction reference if needed.</summary>
         /// <param name="module">The assembly module containing the instruction.</param>
         /// <param name="cil">The CIL processor.</param>
         /// <param name="instruction">The CIL instruction to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        public virtual InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        /// <param name="replaceWith">Replaces the CIL instruction with a new one.</param>
+        /// <returns>Returns whether the instruction was changed.</returns>
+        public virtual bool Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, Action<Instruction> replaceWith)
         {
-            return InstructionHandleResult.None;
+            return false;
         }
 
 
@@ -52,10 +50,28 @@ namespace StardewModdingAPI.Framework.ModLoading.Framework
         ** Protected methods
         *********/
         /// <summary>Construct an instance.</summary>
-        /// <param name="nounPhrase">A brief noun phrase indicating what the handler matches.</param>
-        protected BaseInstructionHandler(string nounPhrase)
+        /// <param name="defaultPhrase">A brief noun phrase indicating what the handler matches.</param>
+        protected BaseInstructionHandler(string defaultPhrase)
+        {
+            this.DefaultPhrase = defaultPhrase;
+        }
+
+        /// <summary>Raise a result flag.</summary>
+        /// <param name="flag">The result flag to set.</param>
+        /// <param name="resultMessage">The result message to add.</param>
+        /// <returns>Returns true for convenience.</returns>
+        protected bool MarkFlag(InstructionHandleResult flag, string resultMessage = null)
+        {
+            this.Flags.Add(flag);
+            if (resultMessage != null)
+                this.Phrases.Add(resultMessage);
+            return true;
+        }
+
+        /// <summary>Raise a generic flag indicating that the code was rewritten.</summary>
+        public bool MarkRewritten()
         {
-            this.NounPhrase = nounPhrase;
+            return this.MarkFlag(InstructionHandleResult.Rewritten);
         }
     }
 }
diff --git a/src/SMAPI/Framework/ModLoading/Framework/BaseTypeFinder.cs b/src/SMAPI/Framework/ModLoading/Framework/BaseTypeFinder.cs
deleted file mode 100644
index 8c85b6a5..00000000
--- a/src/SMAPI/Framework/ModLoading/Framework/BaseTypeFinder.cs
+++ /dev/null
@@ -1,172 +0,0 @@
-using System;
-using System.Linq;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-
-namespace StardewModdingAPI.Framework.ModLoading.Framework
-{
-    /// <summary>Finds incompatible CIL type reference instructions.</summary>
-    internal abstract class BaseTypeFinder : BaseInstructionHandler
-    {
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>Matches the type references to handle.</summary>
-        private readonly Func<TypeReference, bool> IsMatchImpl;
-
-        /// <summary>The result to return for matching instructions.</summary>
-        private readonly InstructionHandleResult Result;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Perform the predefined logic for a method if applicable.</summary>
-        /// <param name="module">The assembly module containing the instruction.</param>
-        /// <param name="method">The method definition to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        public override InstructionHandleResult Handle(ModuleDefinition module, MethodDefinition method, PlatformAssemblyMap assemblyMap, bool platformChanged)
-        {
-            return this.IsMatch(method)
-                ? this.Result
-                : InstructionHandleResult.None;
-        }
-
-        /// <summary>Perform the predefined logic for an instruction if applicable.</summary>
-        /// <param name="module">The assembly module containing the instruction.</param>
-        /// <param name="cil">The CIL processor.</param>
-        /// <param name="instruction">The CIL instruction to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
-        {
-            return this.IsMatch(instruction)
-                ? this.Result
-                : InstructionHandleResult.None;
-        }
-
-        /// <summary>Get whether a CIL instruction matches.</summary>
-        /// <param name="method">The method definition.</param>
-        public bool IsMatch(MethodDefinition method)
-        {
-            // return type
-            if (this.IsMatch(method.ReturnType))
-                return true;
-
-            // parameters
-            foreach (ParameterDefinition parameter in method.Parameters)
-            {
-                if (this.IsMatch(parameter.ParameterType))
-                    return true;
-            }
-
-            // generic parameters
-            foreach (GenericParameter parameter in method.GenericParameters)
-            {
-                if (this.IsMatch(parameter))
-                    return true;
-            }
-
-            // custom attributes
-            foreach (CustomAttribute attribute in method.CustomAttributes)
-            {
-                if (this.IsMatch(attribute.AttributeType))
-                    return true;
-
-                foreach (var arg in attribute.ConstructorArguments)
-                {
-                    if (this.IsMatch(arg.Type))
-                        return true;
-                }
-            }
-
-            // local variables
-            foreach (VariableDefinition variable in method.Body.Variables)
-            {
-                if (this.IsMatch(variable.VariableType))
-                    return true;
-            }
-
-            return false;
-        }
-
-        /// <summary>Get whether a CIL instruction matches.</summary>
-        /// <param name="instruction">The IL instruction.</param>
-        public bool IsMatch(Instruction instruction)
-        {
-            // field reference
-            FieldReference fieldRef = RewriteHelper.AsFieldReference(instruction);
-            if (fieldRef != null)
-            {
-                return
-                    this.IsMatch(fieldRef.DeclaringType) // field on target class
-                    || this.IsMatch(fieldRef.FieldType); // field value is target class
-            }
-
-            // method reference
-            MethodReference methodRef = RewriteHelper.AsMethodReference(instruction);
-            if (methodRef != null)
-            {
-                // method on target class
-                if (this.IsMatch(methodRef.DeclaringType))
-                    return true;
-
-                // method returns target class
-                if (this.IsMatch(methodRef.ReturnType))
-                    return true;
-
-                // method parameters of target class
-                if (methodRef.Parameters.Any(p => this.IsMatch(p.ParameterType)))
-                    return true;
-
-                // generic args of target class
-                if (methodRef is GenericInstanceMethod genericRef && genericRef.GenericArguments.Any(this.IsMatch))
-                    return true;
-            }
-
-            // type reference
-            if (instruction.Operand is TypeReference typeRef && this.IsMatch(typeRef))
-                return true;
-
-            return false;
-        }
-
-        /// <summary>Get whether a type reference matches the expected type.</summary>
-        /// <param name="type">The type to check.</param>
-        public bool IsMatch(TypeReference type)
-        {
-            // root type
-            if (this.IsMatchImpl(type))
-                return true;
-
-            // generic arguments
-            if (type is GenericInstanceType genericType)
-            {
-                if (genericType.GenericArguments.Any(this.IsMatch))
-                    return true;
-            }
-
-            // generic parameters (e.g. constraints)
-            if (type.GenericParameters.Any(this.IsMatch))
-                return true;
-
-            return false;
-        }
-
-
-        /*********
-        ** Protected methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="isMatch">Matches the type references to handle.</param>
-        /// <param name="result">The result to return for matching instructions.</param>
-        /// <param name="nounPhrase">A brief noun phrase indicating what the instruction finder matches.</param>
-        protected BaseTypeFinder(Func<TypeReference, bool> isMatch, InstructionHandleResult result, string nounPhrase)
-            : base(nounPhrase)
-        {
-            this.IsMatchImpl = isMatch;
-            this.Result = result;
-        }
-    }
-}
diff --git a/src/SMAPI/Framework/ModLoading/Framework/BaseTypeReferenceRewriter.cs b/src/SMAPI/Framework/ModLoading/Framework/BaseTypeReferenceRewriter.cs
deleted file mode 100644
index 3ccacf22..00000000
--- a/src/SMAPI/Framework/ModLoading/Framework/BaseTypeReferenceRewriter.cs
+++ /dev/null
@@ -1,209 +0,0 @@
-using System;
-using System.Linq;
-using Mono.Cecil;
-using Mono.Cecil.Cil;
-using Mono.Collections.Generic;
-
-namespace StardewModdingAPI.Framework.ModLoading.Framework
-{
-    /// <summary>Rewrites all references to a type.</summary>
-    internal abstract class BaseTypeReferenceRewriter : BaseInstructionHandler
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The type finder which matches types to rewrite.</summary>
-        private readonly BaseTypeFinder Finder;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Perform the predefined logic for a method if applicable.</summary>
-        /// <param name="module">The assembly module containing the instruction.</param>
-        /// <param name="type">The type definition to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        public override InstructionHandleResult Handle(ModuleDefinition module, TypeDefinition type, PlatformAssemblyMap assemblyMap, bool platformChanged)
-        {
-            bool rewritten = this.RewriteCustomAttributesIfNeeded(module, type.CustomAttributes);
-
-            return rewritten
-                ? InstructionHandleResult.Rewritten
-                : InstructionHandleResult.None;
-        }
-
-        /// <summary>Perform the predefined logic for a method if applicable.</summary>
-        /// <param name="module">The assembly module containing the instruction.</param>
-        /// <param name="method">The method definition to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        public override InstructionHandleResult Handle(ModuleDefinition module, MethodDefinition method, PlatformAssemblyMap assemblyMap, bool platformChanged)
-        {
-            bool rewritten = false;
-
-            // return type
-            if (this.Finder.IsMatch(method.ReturnType))
-                rewritten |= this.RewriteIfNeeded(module, method.ReturnType, newType => method.ReturnType = newType);
-
-            // parameters
-            foreach (ParameterDefinition parameter in method.Parameters)
-            {
-                if (this.Finder.IsMatch(parameter.ParameterType))
-                    rewritten |= this.RewriteIfNeeded(module, parameter.ParameterType, newType => parameter.ParameterType = newType);
-            }
-
-            // generic parameters
-            for (int i = 0; i < method.GenericParameters.Count; i++)
-            {
-                var parameter = method.GenericParameters[i];
-                if (this.Finder.IsMatch(parameter))
-                    rewritten |= this.RewriteIfNeeded(module, parameter, newType => method.GenericParameters[i] = new GenericParameter(parameter.Name, newType));
-            }
-
-            // custom attributes
-            rewritten |= this.RewriteCustomAttributesIfNeeded(module, method.CustomAttributes);
-
-            // local variables
-            foreach (VariableDefinition variable in method.Body.Variables)
-            {
-                if (this.Finder.IsMatch(variable.VariableType))
-                    rewritten |= this.RewriteIfNeeded(module, variable.VariableType, newType => variable.VariableType = newType);
-            }
-
-            return rewritten
-                ? InstructionHandleResult.Rewritten
-                : InstructionHandleResult.None;
-        }
-
-        /// <summary>Perform the predefined logic for an instruction if applicable.</summary>
-        /// <param name="module">The assembly module containing the instruction.</param>
-        /// <param name="cil">The CIL processor.</param>
-        /// <param name="instruction">The CIL instruction to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
-        {
-            if (!this.Finder.IsMatch(instruction))
-                return InstructionHandleResult.None;
-            bool rewritten = false;
-
-            // field reference
-            FieldReference fieldRef = RewriteHelper.AsFieldReference(instruction);
-            if (fieldRef != null)
-            {
-                rewritten |= this.RewriteIfNeeded(module, fieldRef.DeclaringType, newType => fieldRef.DeclaringType = newType);
-                rewritten |= this.RewriteIfNeeded(module, fieldRef.FieldType, newType => fieldRef.FieldType = newType);
-            }
-
-            // method reference
-            MethodReference methodRef = RewriteHelper.AsMethodReference(instruction);
-            if (methodRef != null)
-            {
-                rewritten |= this.RewriteIfNeeded(module, methodRef.DeclaringType, newType => methodRef.DeclaringType = newType);
-                rewritten |= this.RewriteIfNeeded(module, methodRef.ReturnType, newType => methodRef.ReturnType = newType);
-                foreach (var parameter in methodRef.Parameters)
-                    rewritten |= this.RewriteIfNeeded(module, parameter.ParameterType, newType => parameter.ParameterType = newType);
-                if (methodRef is GenericInstanceMethod genericRef)
-                {
-                    for (int i = 0; i < genericRef.GenericArguments.Count; i++)
-                        rewritten |= this.RewriteIfNeeded(module, genericRef.GenericArguments[i], newType => genericRef.GenericArguments[i] = newType);
-                }
-            }
-
-            // type reference
-            if (instruction.Operand is TypeReference typeRef)
-                rewritten |= this.RewriteIfNeeded(module, typeRef, newType => cil.Replace(instruction, cil.Create(instruction.OpCode, newType)));
-
-            return rewritten
-                ? InstructionHandleResult.Rewritten
-                : InstructionHandleResult.None;
-        }
-
-
-        /*********
-        ** Protected methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="finder">The type finder which matches types to rewrite.</param>
-        /// <param name="nounPhrase">A brief noun phrase indicating what the instruction finder matches.</param>
-        protected BaseTypeReferenceRewriter(BaseTypeFinder finder, string nounPhrase)
-            : base(nounPhrase)
-        {
-            this.Finder = finder;
-        }
-
-        /// <summary>Change a type reference if needed.</summary>
-        /// <param name="module">The assembly module containing the instruction.</param>
-        /// <param name="type">The type to replace if it matches.</param>
-        /// <param name="set">Assign the new type reference.</param>
-        protected abstract bool RewriteIfNeeded(ModuleDefinition module, TypeReference type, Action<TypeReference> set);
-
-        /// <summary>Rewrite custom attributes if needed.</summary>
-        /// <param name="module">The assembly module containing the attributes.</param>
-        /// <param name="attributes">The custom attributes to handle.</param>
-        private bool RewriteCustomAttributesIfNeeded(ModuleDefinition module, Collection<CustomAttribute> attributes)
-        {
-            bool rewritten = false;
-
-            for (int attrIndex = 0; attrIndex < attributes.Count; attrIndex++)
-            {
-                CustomAttribute attribute = attributes[attrIndex];
-                bool curChanged = false;
-
-                // attribute type
-                TypeReference newAttrType = null;
-                if (this.Finder.IsMatch(attribute.AttributeType))
-                {
-                    rewritten |= this.RewriteIfNeeded(module, attribute.AttributeType, newType =>
-                    {
-                        newAttrType = newType;
-                        curChanged = true;
-                    });
-                }
-
-                // constructor arguments
-                TypeReference[] argTypes = new TypeReference[attribute.ConstructorArguments.Count];
-                for (int i = 0; i < argTypes.Length; i++)
-                {
-                    var arg = attribute.ConstructorArguments[i];
-
-                    argTypes[i] = arg.Type;
-                    rewritten |= this.RewriteIfNeeded(module, arg.Type, newType =>
-                    {
-                        argTypes[i] = newType;
-                        curChanged = true;
-                    });
-                }
-
-                // swap attribute
-                if (curChanged)
-                {
-                    // get constructor
-                    MethodDefinition constructor = (newAttrType ?? attribute.AttributeType)
-                        .Resolve()
-                        .Methods
-                        .Where(method => method.IsConstructor)
-                        .FirstOrDefault(ctor => RewriteHelper.HasMatchingSignature(ctor, attribute.Constructor));
-                    if (constructor == null)
-                        throw new InvalidOperationException($"Can't rewrite attribute type '{attribute.AttributeType.FullName}' to '{newAttrType?.FullName}', no equivalent constructor found.");
-
-                    // create new attribute
-                    var newAttr = new CustomAttribute(module.ImportReference(constructor));
-                    for (int i = 0; i < argTypes.Length; i++)
-                        newAttr.ConstructorArguments.Add(new CustomAttributeArgument(argTypes[i], attribute.ConstructorArguments[i].Value));
-                    foreach (var prop in attribute.Properties)
-                        newAttr.Properties.Add(new CustomAttributeNamedArgument(prop.Name, prop.Argument));
-                    foreach (var field in attribute.Fields)
-                        newAttr.Fields.Add(new CustomAttributeNamedArgument(field.Name, field.Argument));
-
-                    // swap attribute
-                    attributes[attrIndex] = newAttr;
-                    rewritten = true;
-                }
-            }
-
-            return rewritten;
-        }
-    }
-}
diff --git a/src/SMAPI/Framework/ModLoading/Framework/RecursiveRewriter.cs b/src/SMAPI/Framework/ModLoading/Framework/RecursiveRewriter.cs
new file mode 100644
index 00000000..6aeb00ce
--- /dev/null
+++ b/src/SMAPI/Framework/ModLoading/Framework/RecursiveRewriter.cs
@@ -0,0 +1,260 @@
+using System;
+using System.Linq;
+using Mono.Cecil;
+using Mono.Cecil.Cil;
+using Mono.Collections.Generic;
+
+namespace StardewModdingAPI.Framework.ModLoading.Framework
+{
+    /// <summary>Handles recursively rewriting loaded assembly code.</summary>
+    internal class RecursiveRewriter
+    {
+        /*********
+        ** Delegates
+        *********/
+        /// <summary>Rewrite a type reference in the assembly code.</summary>
+        /// <param name="type">The current type reference.</param>
+        /// <param name="replaceWith">Replaces the type reference with the given type.</param>
+        /// <returns>Returns whether the type was changed.</returns>
+        public delegate bool RewriteTypeDelegate(TypeReference type, Action<TypeReference> replaceWith);
+
+        /// <summary>Rewrite a CIL instruction in the assembly code.</summary>
+        /// <param name="instruction">The current CIL instruction.</param>
+        /// <param name="cil">The CIL instruction processor.</param>
+        /// <param name="replaceWith">Replaces the CIL instruction with the given instruction.</param>
+        /// <returns>Returns whether the instruction was changed.</returns>
+        public delegate bool RewriteInstructionDelegate(Instruction instruction, ILProcessor cil, Action<Instruction> replaceWith);
+
+
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>The module to rewrite.</summary>
+        public ModuleDefinition Module { get; }
+
+        /// <summary>Handle or rewrite a type reference if needed.</summary>
+        public RewriteTypeDelegate RewriteTypeImpl { get; }
+
+        /// <summary>Handle or rewrite a CIL instruction if needed.</summary>
+        public RewriteInstructionDelegate RewriteInstructionImpl { get; }
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="module">The module to rewrite.</param>
+        /// <param name="rewriteType">Handle or rewrite a type reference if needed.</param>
+        /// <param name="rewriteInstruction">Handle or rewrite a CIL instruction if needed.</param>
+        public RecursiveRewriter(ModuleDefinition module, RewriteTypeDelegate rewriteType, RewriteInstructionDelegate rewriteInstruction)
+        {
+            this.Module = module;
+            this.RewriteTypeImpl = rewriteType;
+            this.RewriteInstructionImpl = rewriteInstruction;
+        }
+
+        /// <summary>Rewrite the loaded module code.</summary>
+        /// <returns>Returns whether the module was modified.</returns>
+        public bool RewriteModule()
+        {
+            bool anyRewritten = false;
+
+            foreach (TypeDefinition type in this.Module.GetTypes())
+            {
+                anyRewritten |= this.RewriteCustomAttributes(type.CustomAttributes);
+                anyRewritten |= this.RewriteGenericParameters(type.GenericParameters);
+
+                foreach (MethodDefinition method in type.Methods.Where(p => p.HasBody))
+                {
+                    anyRewritten |= this.RewriteTypeReference(method.ReturnType, newType => method.ReturnType = newType);
+                    anyRewritten |= this.RewriteGenericParameters(method.GenericParameters);
+                    anyRewritten |= this.RewriteCustomAttributes(method.CustomAttributes);
+
+                    foreach (ParameterDefinition parameter in method.Parameters)
+                        anyRewritten |= this.RewriteTypeReference(parameter.ParameterType, newType => parameter.ParameterType = newType);
+
+                    foreach (VariableDefinition variable in method.Body.Variables)
+                        anyRewritten |= this.RewriteTypeReference(variable.VariableType, newType => variable.VariableType = newType);
+
+                    // check CIL instructions
+                    ILProcessor cil = method.Body.GetILProcessor();
+                    Collection<Instruction> instructions = cil.Body.Instructions;
+                    for (int i = 0; i < instructions.Count; i++)
+                    {
+                        var instruction = instructions[i];
+                        if (instruction.OpCode.Code == Code.Nop)
+                            continue;
+
+                        anyRewritten |= this.RewriteInstruction(instruction, cil, newInstruction =>
+                        {
+                            anyRewritten = true;
+                            cil.Replace(instruction, newInstruction);
+                            instruction = newInstruction;
+                        });
+                    }
+                }
+            }
+
+            return anyRewritten;
+        }
+
+
+        /*********
+        ** Private methods
+        *********/
+        /// <summary>Rewrite a CIL instruction if needed.</summary>
+        /// <param name="instruction">The current CIL instruction.</param>
+        /// <param name="cil">The CIL instruction processor.</param>
+        /// <param name="replaceWith">Replaces the CIL instruction with a new one.</param>
+        private bool RewriteInstruction(Instruction instruction, ILProcessor cil, Action<Instruction> replaceWith)
+        {
+            bool rewritten = false;
+
+            // field reference
+            FieldReference fieldRef = RewriteHelper.AsFieldReference(instruction);
+            if (fieldRef != null)
+            {
+                rewritten |= this.RewriteTypeReference(fieldRef.DeclaringType, newType => fieldRef.DeclaringType = newType);
+                rewritten |= this.RewriteTypeReference(fieldRef.FieldType, newType => fieldRef.FieldType = newType);
+            }
+
+            // method reference
+            MethodReference methodRef = RewriteHelper.AsMethodReference(instruction);
+            if (methodRef != null)
+            {
+                rewritten |= this.RewriteTypeReference(methodRef.DeclaringType, newType => methodRef.DeclaringType = newType);
+                rewritten |= this.RewriteTypeReference(methodRef.ReturnType, newType => methodRef.ReturnType = newType);
+
+                foreach (var parameter in methodRef.Parameters)
+                    rewritten |= this.RewriteTypeReference(parameter.ParameterType, newType => parameter.ParameterType = newType);
+
+                if (methodRef is GenericInstanceMethod genericRef)
+                {
+                    for (int i = 0; i < genericRef.GenericArguments.Count; i++)
+                        rewritten |= this.RewriteTypeReference(genericRef.GenericArguments[i], newType => genericRef.GenericArguments[i] = newType);
+                }
+            }
+
+            // type reference
+            if (instruction.Operand is TypeReference typeRef)
+                rewritten |= this.RewriteTypeReference(typeRef, newType => replaceWith(cil.Create(instruction.OpCode, newType)));
+
+            // instruction itself
+            // (should be done after the above type rewrites to ensure valid types)
+            rewritten |= this.RewriteInstructionImpl(instruction, cil, newInstruction =>
+            {
+                rewritten = true;
+                cil.Replace(instruction, newInstruction);
+                instruction = newInstruction;
+            });
+
+            return rewritten;
+        }
+
+        /// <summary>Rewrite a type reference if needed.</summary>
+        /// <param name="type">The current type reference.</param>
+        /// <param name="replaceWith">Replaces the type reference with a new one.</param>
+        private bool RewriteTypeReference(TypeReference type, Action<TypeReference> replaceWith)
+        {
+            bool rewritten = false;
+
+            // type
+            rewritten |= this.RewriteTypeImpl(type, newType =>
+            {
+                type = newType;
+                replaceWith(newType);
+                rewritten = true;
+            });
+
+            // generic arguments
+            if (type is GenericInstanceType genericType)
+            {
+                for (int i = 0; i < genericType.GenericArguments.Count; i++)
+                    rewritten |= this.RewriteTypeReference(genericType.GenericArguments[i], typeRef => genericType.GenericArguments[i] = typeRef);
+            }
+
+            // generic parameters (e.g. constraints)
+            rewritten |= this.RewriteGenericParameters(type.GenericParameters);
+
+            return rewritten;
+        }
+
+        /// <summary>Rewrite custom attributes if needed.</summary>
+        /// <param name="attributes">The current custom attributes.</param>
+        private bool RewriteCustomAttributes(Collection<CustomAttribute> attributes)
+        {
+            bool rewritten = false;
+
+            for (int attrIndex = 0; attrIndex < attributes.Count; attrIndex++)
+            {
+                CustomAttribute attribute = attributes[attrIndex];
+                bool curChanged = false;
+
+                // attribute type
+                TypeReference newAttrType = null;
+                rewritten |= this.RewriteTypeReference(attribute.AttributeType, newType =>
+                {
+                    newAttrType = newType;
+                    curChanged = true;
+                });
+
+                // constructor arguments
+                TypeReference[] argTypes = new TypeReference[attribute.ConstructorArguments.Count];
+                for (int i = 0; i < argTypes.Length; i++)
+                {
+                    var arg = attribute.ConstructorArguments[i];
+
+                    argTypes[i] = arg.Type;
+                    rewritten |= this.RewriteTypeReference(arg.Type, newType =>
+                    {
+                        argTypes[i] = newType;
+                        curChanged = true;
+                    });
+                }
+
+                // swap attribute
+                if (curChanged)
+                {
+                    // get constructor
+                    MethodDefinition constructor = (newAttrType ?? attribute.AttributeType)
+                        .Resolve()
+                        .Methods
+                        .Where(method => method.IsConstructor)
+                        .FirstOrDefault(ctor => RewriteHelper.HasMatchingSignature(ctor, attribute.Constructor));
+                    if (constructor == null)
+                        throw new InvalidOperationException($"Can't rewrite attribute type '{attribute.AttributeType.FullName}' to '{newAttrType?.FullName}', no equivalent constructor found.");
+
+                    // create new attribute
+                    var newAttr = new CustomAttribute(this.Module.ImportReference(constructor));
+                    for (int i = 0; i < argTypes.Length; i++)
+                        newAttr.ConstructorArguments.Add(new CustomAttributeArgument(argTypes[i], attribute.ConstructorArguments[i].Value));
+                    foreach (var prop in attribute.Properties)
+                        newAttr.Properties.Add(new CustomAttributeNamedArgument(prop.Name, prop.Argument));
+                    foreach (var field in attribute.Fields)
+                        newAttr.Fields.Add(new CustomAttributeNamedArgument(field.Name, field.Argument));
+
+                    // swap attribute
+                    attributes[attrIndex] = newAttr;
+                    rewritten = true;
+                }
+            }
+
+            return rewritten;
+        }
+
+        /// <summary>Rewrites generic type parameters if needed.</summary>
+        /// <param name="parameters">The current generic type parameters.</param>
+        private bool RewriteGenericParameters(Collection<GenericParameter> parameters)
+        {
+            bool anyChanged = false;
+
+            for (int i = 0; i < parameters.Count; i++)
+            {
+                TypeReference parameter = parameters[i];
+                anyChanged |= this.RewriteTypeReference(parameter, newType => parameters[i] = new GenericParameter(parameter.Name, newType));
+            }
+
+            return anyChanged;
+        }
+    }
+}
diff --git a/src/SMAPI/Framework/ModLoading/RewriteHelper.cs b/src/SMAPI/Framework/ModLoading/Framework/RewriteHelper.cs
index 553679f9..91c9dec3 100644
--- a/src/SMAPI/Framework/ModLoading/RewriteHelper.cs
+++ b/src/SMAPI/Framework/ModLoading/Framework/RewriteHelper.cs
@@ -4,7 +4,7 @@ using System.Reflection;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 
-namespace StardewModdingAPI.Framework.ModLoading
+namespace StardewModdingAPI.Framework.ModLoading.Framework
 {
     /// <summary>Provides helper methods for field rewriters.</summary>
     internal static class RewriteHelper
@@ -28,6 +28,28 @@ namespace StardewModdingAPI.Framework.ModLoading
                 : null;
         }
 
+        /// <summary>Get whether the field is a reference to the expected type and field.</summary>
+        /// <param name="instruction">The IL instruction.</param>
+        /// <param name="fullTypeName">The full type name containing the expected field.</param>
+        /// <param name="fieldName">The name of the expected field.</param>
+        public static bool IsFieldReferenceTo(Instruction instruction, string fullTypeName, string fieldName)
+        {
+            FieldReference fieldRef = RewriteHelper.AsFieldReference(instruction);
+            return RewriteHelper.IsFieldReferenceTo(fieldRef, fullTypeName, fieldName);
+        }
+
+        /// <summary>Get whether the field is a reference to the expected type and field.</summary>
+        /// <param name="fieldRef">The field reference to check.</param>
+        /// <param name="fullTypeName">The full type name containing the expected field.</param>
+        /// <param name="fieldName">The name of the expected field.</param>
+        public static bool IsFieldReferenceTo(FieldReference fieldRef, string fullTypeName, string fieldName)
+        {
+            return
+                fieldRef != null
+                && fieldRef.DeclaringType.FullName == fullTypeName
+                && fieldRef.Name == fieldName;
+        }
+
         /// <summary>Get the method reference from an instruction if it matches.</summary>
         /// <param name="instruction">The IL instruction.</param>
         public static MethodReference AsMethodReference(Instruction instruction)
diff --git a/src/SMAPI/Framework/ModLoading/IInstructionHandler.cs b/src/SMAPI/Framework/ModLoading/IInstructionHandler.cs
index f9d320a6..e6de6785 100644
--- a/src/SMAPI/Framework/ModLoading/IInstructionHandler.cs
+++ b/src/SMAPI/Framework/ModLoading/IInstructionHandler.cs
@@ -1,3 +1,5 @@
+using System;
+using System.Collections.Generic;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 
@@ -9,33 +11,32 @@ namespace StardewModdingAPI.Framework.ModLoading
         /*********
         ** Accessors
         *********/
-        /// <summary>A brief noun phrase indicating what the handler matches.</summary>
-        string NounPhrase { get; }
+        /// <summary>A brief noun phrase indicating what the handler matches, used if <see cref="Phrases"/> is empty.</summary>
+        string DefaultPhrase { get; }
+
+        /// <summary>The rewrite flags raised for the current module.</summary>
+        ISet<InstructionHandleResult> Flags { get; }
+
+        /// <summary>The brief noun phrases indicating what the handler matched for the current module.</summary>
+        ISet<string> Phrases { get; }
 
 
         /*********
         ** Methods
         *********/
-        /// <summary>Perform the predefined logic for a method if applicable.</summary>
+        /// <summary>Rewrite a type reference if needed.</summary>
         /// <param name="module">The assembly module containing the instruction.</param>
         /// <param name="type">The type definition to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        InstructionHandleResult Handle(ModuleDefinition module, TypeDefinition type, PlatformAssemblyMap assemblyMap, bool platformChanged);
-
-        /// <summary>Perform the predefined logic for a method if applicable.</summary>
-        /// <param name="module">The assembly module containing the instruction.</param>
-        /// <param name="method">The method definition to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        InstructionHandleResult Handle(ModuleDefinition module, MethodDefinition method, PlatformAssemblyMap assemblyMap, bool platformChanged);
+        /// <param name="replaceWith">Replaces the type reference with a new one.</param>
+        /// <returns>Returns whether the type was changed.</returns>
+        bool Handle(ModuleDefinition module, TypeReference type, Action<TypeReference> replaceWith);
 
-        /// <summary>Perform the predefined logic for an instruction if applicable.</summary>
+        /// <summary>Rewrite a CIL instruction reference if needed.</summary>
         /// <param name="module">The assembly module containing the instruction.</param>
         /// <param name="cil">The CIL processor.</param>
         /// <param name="instruction">The CIL instruction to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged);
+        /// <param name="replaceWith">Replaces the CIL instruction with a new one.</param>
+        /// <returns>Returns whether the instruction was changed.</returns>
+        bool Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, Action<Instruction> replaceWith);
     }
 }
diff --git a/src/SMAPI/Framework/ModLoading/Rewriters/FieldReplaceRewriter.cs b/src/SMAPI/Framework/ModLoading/Rewriters/FieldReplaceRewriter.cs
index ff86c6e2..8043b13a 100644
--- a/src/SMAPI/Framework/ModLoading/Rewriters/FieldReplaceRewriter.cs
+++ b/src/SMAPI/Framework/ModLoading/Rewriters/FieldReplaceRewriter.cs
@@ -2,16 +2,22 @@ using System;
 using System.Reflection;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
-using StardewModdingAPI.Framework.ModLoading.Finders;
+using StardewModdingAPI.Framework.ModLoading.Framework;
 
 namespace StardewModdingAPI.Framework.ModLoading.Rewriters
 {
     /// <summary>Rewrites references to one field with another.</summary>
-    internal class FieldReplaceRewriter : FieldFinder
+    internal class FieldReplaceRewriter : BaseInstructionHandler
     {
         /*********
         ** Fields
         *********/
+        /// <summary>The type containing the field to which references should be rewritten.</summary>
+        private readonly Type Type;
+
+        /// <summary>The field name to which references should be rewritten.</summary>
+        private readonly string FromFieldName;
+
         /// <summary>The new field to reference.</summary>
         private readonly FieldInfo ToField;
 
@@ -20,31 +26,36 @@ namespace StardewModdingAPI.Framework.ModLoading.Rewriters
         ** Public methods
         *********/
         /// <summary>Construct an instance.</summary>
-        /// <param name="type">The type whose field to which references should be rewritten.</param>
+        /// <param name="type">The type whose field to rewrite.</param>
         /// <param name="fromFieldName">The field name to rewrite.</param>
         /// <param name="toFieldName">The new field name to reference.</param>
         public FieldReplaceRewriter(Type type, string fromFieldName, string toFieldName)
-            : base(type.FullName, fromFieldName, InstructionHandleResult.None)
+            : base(defaultPhrase: $"{type.FullName}.{fromFieldName} field")
         {
+            this.Type = type;
+            this.FromFieldName = fromFieldName;
             this.ToField = type.GetField(toFieldName);
             if (this.ToField == null)
                 throw new InvalidOperationException($"The {type.FullName} class doesn't have a {toFieldName} field.");
         }
 
-        /// <summary>Perform the predefined logic for an instruction if applicable.</summary>
+        /// <summary>Rewrite a CIL instruction reference if needed.</summary>
         /// <param name="module">The assembly module containing the instruction.</param>
         /// <param name="cil">The CIL processor.</param>
-        /// <param name="instruction">The instruction to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        /// <param name="instruction">The CIL instruction to handle.</param>
+        /// <param name="replaceWith">Replaces the CIL instruction with a new one.</param>
+        /// <returns>Returns whether the instruction was changed.</returns>
+        public override bool Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, Action<Instruction> replaceWith)
         {
-            if (!this.IsMatch(instruction))
-                return InstructionHandleResult.None;
+            // get field reference
+            FieldReference fieldRef = RewriteHelper.AsFieldReference(instruction);
+            if (!RewriteHelper.IsFieldReferenceTo(fieldRef, this.Type.FullName, this.FromFieldName))
+                return false;
 
+            // replace with new field
             FieldReference newRef = module.ImportReference(this.ToField);
-            cil.Replace(instruction, cil.Create(instruction.OpCode, newRef));
-            return InstructionHandleResult.Rewritten;
+            replaceWith(cil.Create(instruction.OpCode, newRef));
+            return this.MarkRewritten();
         }
     }
 }
diff --git a/src/SMAPI/Framework/ModLoading/Rewriters/FieldToPropertyRewriter.cs b/src/SMAPI/Framework/ModLoading/Rewriters/FieldToPropertyRewriter.cs
index a43c5e9a..c3b5854e 100644
--- a/src/SMAPI/Framework/ModLoading/Rewriters/FieldToPropertyRewriter.cs
+++ b/src/SMAPI/Framework/ModLoading/Rewriters/FieldToPropertyRewriter.cs
@@ -1,21 +1,24 @@
 using System;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
-using StardewModdingAPI.Framework.ModLoading.Finders;
+using StardewModdingAPI.Framework.ModLoading.Framework;
 
 namespace StardewModdingAPI.Framework.ModLoading.Rewriters
 {
     /// <summary>Rewrites field references into property references.</summary>
-    internal class FieldToPropertyRewriter : FieldFinder
+    internal class FieldToPropertyRewriter : BaseInstructionHandler
     {
         /*********
         ** Fields
         *********/
-        /// <summary>The type whose field to which references should be rewritten.</summary>
+        /// <summary>The type containing the field to which references should be rewritten.</summary>
         private readonly Type Type;
 
-        /// <summary>The property name.</summary>
-        private readonly string PropertyName;
+        /// <summary>The field name to which references should be rewritten.</summary>
+        private readonly string FromFieldName;
+
+        /// <summary>The new property name.</summary>
+        private readonly string ToPropertyName;
 
 
         /*********
@@ -26,10 +29,11 @@ namespace StardewModdingAPI.Framework.ModLoading.Rewriters
         /// <param name="fieldName">The field name to rewrite.</param>
         /// <param name="propertyName">The property name (if different).</param>
         public FieldToPropertyRewriter(Type type, string fieldName, string propertyName)
-            : base(type.FullName, fieldName, InstructionHandleResult.None)
+            : base(defaultPhrase: $"{type.FullName}.{fieldName} field")
         {
             this.Type = type;
-            this.PropertyName = propertyName;
+            this.FromFieldName = fieldName;
+            this.ToPropertyName = propertyName;
         }
 
         /// <summary>Construct an instance.</summary>
@@ -38,22 +42,24 @@ namespace StardewModdingAPI.Framework.ModLoading.Rewriters
         public FieldToPropertyRewriter(Type type, string fieldName)
             : this(type, fieldName, fieldName) { }
 
-        /// <summary>Perform the predefined logic for an instruction if applicable.</summary>
+        /// <summary>Rewrite a CIL instruction reference if needed.</summary>
         /// <param name="module">The assembly module containing the instruction.</param>
         /// <param name="cil">The CIL processor.</param>
-        /// <param name="instruction">The instruction to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        /// <param name="instruction">The CIL instruction to handle.</param>
+        /// <param name="replaceWith">Replaces the CIL instruction with a new one.</param>
+        /// <returns>Returns whether the instruction was changed.</returns>
+        public override bool Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, Action<Instruction> replaceWith)
         {
-            if (!this.IsMatch(instruction))
-                return InstructionHandleResult.None;
+            // get field ref
+            FieldReference fieldRef = RewriteHelper.AsFieldReference(instruction);
+            if (!RewriteHelper.IsFieldReferenceTo(fieldRef, this.Type.FullName, this.FromFieldName))
+                return false;
 
+            // replace with property
             string methodPrefix = instruction.OpCode == OpCodes.Ldsfld || instruction.OpCode == OpCodes.Ldfld ? "get" : "set";
-            MethodReference propertyRef = module.ImportReference(this.Type.GetMethod($"{methodPrefix}_{this.PropertyName}"));
-            cil.Replace(instruction, cil.Create(OpCodes.Call, propertyRef));
-
-            return InstructionHandleResult.Rewritten;
+            MethodReference propertyRef = module.ImportReference(this.Type.GetMethod($"{methodPrefix}_{this.ToPropertyName}"));
+            replaceWith(cil.Create(OpCodes.Call, propertyRef));
+            return this.MarkRewritten();
         }
     }
 }
diff --git a/src/SMAPI/Framework/ModLoading/Rewriters/Harmony1AssemblyRewriter.cs b/src/SMAPI/Framework/ModLoading/Rewriters/Harmony1AssemblyRewriter.cs
index 9faca235..a7a0b9c3 100644
--- a/src/SMAPI/Framework/ModLoading/Rewriters/Harmony1AssemblyRewriter.cs
+++ b/src/SMAPI/Framework/ModLoading/Rewriters/Harmony1AssemblyRewriter.cs
@@ -1,28 +1,20 @@
 using System;
+using HarmonyLib;
 using Mono.Cecil;
-using StardewModdingAPI.Framework.ModLoading.Finders;
+using Mono.Cecil.Cil;
 using StardewModdingAPI.Framework.ModLoading.Framework;
+using StardewModdingAPI.Framework.ModLoading.RewriteFacades;
 
 namespace StardewModdingAPI.Framework.ModLoading.Rewriters
 {
     /// <summary>Rewrites Harmony 1.x assembly references to work with Harmony 2.x.</summary>
-    internal class Harmony1AssemblyRewriter : BaseTypeReferenceRewriter
+    internal class Harmony1AssemblyRewriter : BaseInstructionHandler
     {
         /*********
         ** Fields
         *********/
-        /// <summary>The full assembly name to which to find references.</summary>
-        private const string FromAssemblyName = "0Harmony";
-
-        /// <summary>The main Harmony type.</summary>
-        private readonly Type HarmonyType = typeof(HarmonyLib.Harmony);
-
-
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>A brief noun phrase indicating what the rewriter matches.</summary>
-        public const string DefaultNounPhrase = "Harmony 1.x";
+        /// <summary>Whether any Harmony 1.x types were replaced.</summary>
+        private bool ReplacedTypes;
 
 
         /*********
@@ -30,41 +22,80 @@ namespace StardewModdingAPI.Framework.ModLoading.Rewriters
         *********/
         /// <summary>Construct an instance.</summary>
         public Harmony1AssemblyRewriter()
-            : base(new TypeAssemblyFinder(Harmony1AssemblyRewriter.FromAssemblyName, InstructionHandleResult.None), Harmony1AssemblyRewriter.DefaultNounPhrase)
-        { }
+            : base(defaultPhrase: "Harmony 1.x") { }
+
+        /// <summary>Rewrite a type reference if needed.</summary>
+        /// <param name="module">The assembly module containing the instruction.</param>
+        /// <param name="type">The type definition to handle.</param>
+        /// <param name="replaceWith">Replaces the type reference with a new one.</param>
+        /// <returns>Returns whether the type was changed.</returns>
+        public override bool Handle(ModuleDefinition module, TypeReference type, Action<TypeReference> replaceWith)
+        {
+            // rewrite Harmony 1.x type to Harmony 2.0 type
+            if (type.Scope is AssemblyNameReference scope && scope.Name == "0Harmony" && scope.Version.Major == 1)
+            {
+                Type targetType = this.GetMappedType(type);
+                replaceWith(module.ImportReference(targetType));
+                this.MarkRewritten();
+                this.ReplacedTypes = true;
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>Rewrite a CIL instruction reference if needed.</summary>
+        /// <param name="module">The assembly module containing the instruction.</param>
+        /// <param name="cil">The CIL processor.</param>
+        /// <param name="instruction">The CIL instruction to handle.</param>
+        /// <param name="replaceWith">Replaces the CIL instruction with a new one.</param>
+        /// <returns>Returns whether the instruction was changed.</returns>
+        public override bool Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, Action<Instruction> replaceWith)
+        {
+            // rewrite Harmony 1.x methods to Harmony 2.0
+            MethodReference methodRef = RewriteHelper.AsMethodReference(instruction);
+            if (this.TryRewriteMethodsToFacade(module, methodRef))
+                return true;
+
+            return false;
+        }
 
 
         /*********
         ** Private methods
         *********/
-        /// <summary>Change a type reference if needed.</summary>
-        /// <param name="module">The assembly module containing the instruction.</param>
-        /// <param name="type">The type to replace if it matches.</param>
-        /// <param name="set">Assign the new type reference.</param>
-        protected override bool RewriteIfNeeded(ModuleDefinition module, TypeReference type, Action<TypeReference> set)
+        /// <summary>Rewrite methods to use Harmony facades if needed.</summary>
+        /// <param name="module">The assembly module containing the method reference.</param>
+        /// <param name="methodRef">The method reference to map.</param>
+        private bool TryRewriteMethodsToFacade(ModuleDefinition module, MethodReference methodRef)
         {
-            bool rewritten = false;
+            if (!this.ReplacedTypes)
+                return false; // not Harmony (or already using Harmony 2.0)
 
-            // current type
-            if (type.Scope.Name == Harmony1AssemblyRewriter.FromAssemblyName && type.Scope is AssemblyNameReference assemblyScope && assemblyScope.Version.Major == 1)
+            // get facade type
+            Type toType;
+            switch (methodRef?.DeclaringType.FullName)
             {
-                Type targetType = this.GetMappedType(type);
-                set(module.ImportReference(targetType));
-                return true;
+                case "HarmonyLib.Harmony":
+                    toType = typeof(HarmonyInstanceMethods);
+                    break;
+
+                case "HarmonyLib.AccessTools":
+                    toType = typeof(AccessToolsMethods);
+                    break;
+
+                default:
+                    return false;
             }
 
-            // recurse into generic arguments
-            if (type is GenericInstanceType genericType)
+            // map if there's a matching method
+            if (RewriteHelper.HasMatchingSignature(toType, methodRef))
             {
-                for (int i = 0; i < genericType.GenericArguments.Count; i++)
-                    rewritten |= this.RewriteIfNeeded(module, genericType.GenericArguments[i], typeRef => genericType.GenericArguments[i] = typeRef);
+                methodRef.DeclaringType = module.ImportReference(toType);
+                return true;
             }
 
-            // recurse into generic parameters (e.g. constraints)
-            for (int i = 0; i < type.GenericParameters.Count; i++)
-                rewritten |= this.RewriteIfNeeded(module, type.GenericParameters[i], typeRef => type.GenericParameters[i] = new GenericParameter(typeRef));
-
-            return rewritten;
+            return false;
         }
 
         /// <summary>Get an equivalent Harmony 2.x type.</summary>
@@ -73,11 +104,11 @@ namespace StardewModdingAPI.Framework.ModLoading.Rewriters
         {
             // main Harmony object
             if (type.FullName == "Harmony.HarmonyInstance")
-                return this.HarmonyType;
+                return typeof(Harmony);
 
             // other objects
             string fullName = type.FullName.Replace("Harmony.", "HarmonyLib.");
-            string targetName = this.HarmonyType.AssemblyQualifiedName.Replace(this.HarmonyType.FullName, fullName);
+            string targetName = typeof(Harmony).AssemblyQualifiedName.Replace(typeof(Harmony).FullName, fullName);
             return Type.GetType(targetName, throwOnError: true);
         }
     }
diff --git a/src/SMAPI/Framework/ModLoading/Rewriters/MethodParentRewriter.cs b/src/SMAPI/Framework/ModLoading/Rewriters/MethodParentRewriter.cs
index d0fe8b13..b8e53f40 100644
--- a/src/SMAPI/Framework/ModLoading/Rewriters/MethodParentRewriter.cs
+++ b/src/SMAPI/Framework/ModLoading/Rewriters/MethodParentRewriter.cs
@@ -18,9 +18,6 @@ namespace StardewModdingAPI.Framework.ModLoading.Rewriters
         /// <summary>The type with methods to map to.</summary>
         private readonly Type ToType;
 
-        /// <summary>Whether to only rewrite references if loading the assembly on a different platform than it was compiled on.</summary>
-        private readonly bool OnlyIfPlatformChanged;
-
 
         /*********
         ** Public methods
@@ -28,54 +25,49 @@ namespace StardewModdingAPI.Framework.ModLoading.Rewriters
         /// <summary>Construct an instance.</summary>
         /// <param name="fromType">The type whose methods to remap.</param>
         /// <param name="toType">The type with methods to map to.</param>
-        /// <param name="onlyIfPlatformChanged">Whether to only rewrite references if loading the assembly on a different platform than it was compiled on.</param>
         /// <param name="nounPhrase">A brief noun phrase indicating what the instruction finder matches (or <c>null</c> to generate one).</param>
-        public MethodParentRewriter(string fromType, Type toType, bool onlyIfPlatformChanged = false, string nounPhrase = null)
+        public MethodParentRewriter(string fromType, Type toType, string nounPhrase = null)
             : base(nounPhrase ?? $"{fromType.Split('.').Last()} methods")
         {
             this.FromType = fromType;
             this.ToType = toType;
-            this.OnlyIfPlatformChanged = onlyIfPlatformChanged;
         }
 
         /// <summary>Construct an instance.</summary>
         /// <param name="fromType">The type whose methods to remap.</param>
         /// <param name="toType">The type with methods to map to.</param>
-        /// <param name="onlyIfPlatformChanged">Whether to only rewrite references if loading the assembly on a different platform than it was compiled on.</param>
         /// <param name="nounPhrase">A brief noun phrase indicating what the instruction finder matches (or <c>null</c> to generate one).</param>
-        public MethodParentRewriter(Type fromType, Type toType, bool onlyIfPlatformChanged = false, string nounPhrase = null)
-            : this(fromType.FullName, toType, onlyIfPlatformChanged, nounPhrase) { }
-
+        public MethodParentRewriter(Type fromType, Type toType, string nounPhrase = null)
+            : this(fromType.FullName, toType, nounPhrase) { }
 
-        /// <summary>Perform the predefined logic for an instruction if applicable.</summary>
+        /// <summary>Rewrite a CIL instruction reference if needed.</summary>
         /// <param name="module">The assembly module containing the instruction.</param>
         /// <param name="cil">The CIL processor.</param>
         /// <param name="instruction">The CIL instruction to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        /// <param name="replaceWith">Replaces the CIL instruction with a new one.</param>
+        /// <returns>Returns whether the instruction was changed.</returns>
+        public override bool Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, Action<Instruction> replaceWith)
         {
-            if (!this.IsMatch(instruction, platformChanged))
-                return InstructionHandleResult.None;
+            // get method ref
+            MethodReference methodRef = RewriteHelper.AsMethodReference(instruction);
+            if (!this.IsMatch(methodRef))
+                return false;
 
-            MethodReference methodRef = (MethodReference)instruction.Operand;
+            // rewrite
             methodRef.DeclaringType = module.ImportReference(this.ToType);
-            return InstructionHandleResult.Rewritten;
+            return this.MarkRewritten();
         }
 
 
         /*********
-        ** Protected methods
+        ** Private methods
         *********/
         /// <summary>Get whether a CIL instruction matches.</summary>
-        /// <param name="instruction">The IL instruction.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        protected bool IsMatch(Instruction instruction, bool platformChanged)
+        /// <param name="methodRef">The method reference.</param>
+        private bool IsMatch(MethodReference methodRef)
         {
-            MethodReference methodRef = RewriteHelper.AsMethodReference(instruction);
             return
                 methodRef != null
-                && (platformChanged || !this.OnlyIfPlatformChanged)
                 && methodRef.DeclaringType.FullName == this.FromType
                 && RewriteHelper.HasMatchingSignature(this.ToType, methodRef);
         }
diff --git a/src/SMAPI/Framework/ModLoading/Rewriters/StaticFieldToConstantRewriter.cs b/src/SMAPI/Framework/ModLoading/Rewriters/StaticFieldToConstantRewriter.cs
index 7e7c0efa..6ef18b26 100644
--- a/src/SMAPI/Framework/ModLoading/Rewriters/StaticFieldToConstantRewriter.cs
+++ b/src/SMAPI/Framework/ModLoading/Rewriters/StaticFieldToConstantRewriter.cs
@@ -1,17 +1,23 @@
 using System;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
-using StardewModdingAPI.Framework.ModLoading.Finders;
+using StardewModdingAPI.Framework.ModLoading.Framework;
 
 namespace StardewModdingAPI.Framework.ModLoading.Rewriters
 {
     /// <summary>Rewrites static field references into constant values.</summary>
     /// <typeparam name="TValue">The constant value type.</typeparam>
-    internal class StaticFieldToConstantRewriter<TValue> : FieldFinder
+    internal class StaticFieldToConstantRewriter<TValue> : BaseInstructionHandler
     {
         /*********
         ** Fields
         *********/
+        /// <summary>The type containing the field to which references should be rewritten.</summary>
+        private readonly Type Type;
+
+        /// <summary>The field name to which references should be rewritten.</summary>
+        private readonly string FromFieldName;
+
         /// <summary>The constant value to replace with.</summary>
         private readonly TValue Value;
 
@@ -24,24 +30,29 @@ namespace StardewModdingAPI.Framework.ModLoading.Rewriters
         /// <param name="fieldName">The field name to rewrite.</param>
         /// <param name="value">The constant value to replace with.</param>
         public StaticFieldToConstantRewriter(Type type, string fieldName, TValue value)
-            : base(type.FullName, fieldName, InstructionHandleResult.None)
+            : base(defaultPhrase: $"{type.FullName}.{fieldName} field")
         {
+            this.Type = type;
+            this.FromFieldName = fieldName;
             this.Value = value;
         }
 
-        /// <summary>Perform the predefined logic for an instruction if applicable.</summary>
+        /// <summary>Rewrite a CIL instruction reference if needed.</summary>
         /// <param name="module">The assembly module containing the instruction.</param>
         /// <param name="cil">The CIL processor.</param>
-        /// <param name="instruction">The instruction to handle.</param>
-        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
-        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
-        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        /// <param name="instruction">The CIL instruction to handle.</param>
+        /// <param name="replaceWith">Replaces the CIL instruction with a new one.</param>
+        /// <returns>Returns whether the instruction was changed.</returns>
+        public override bool Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, Action<Instruction> replaceWith)
         {
-            if (!this.IsMatch(instruction))
-                return InstructionHandleResult.None;
+            // get field reference
+            FieldReference fieldRef = RewriteHelper.AsFieldReference(instruction);
+            if (!RewriteHelper.IsFieldReferenceTo(fieldRef, this.Type.FullName, this.FromFieldName))
+                return false;
 
-            cil.Replace(instruction, this.CreateConstantInstruction(cil, this.Value));
-            return InstructionHandleResult.Rewritten;
+            // rewrite to constant
+            replaceWith(this.CreateConstantInstruction(cil, this.Value));
+            return this.MarkRewritten();
         }
 
 
diff --git a/src/SMAPI/Framework/ModLoading/Rewriters/TypeReferenceRewriter.cs b/src/SMAPI/Framework/ModLoading/Rewriters/TypeReferenceRewriter.cs
index d95e5ac9..c2120444 100644
--- a/src/SMAPI/Framework/ModLoading/Rewriters/TypeReferenceRewriter.cs
+++ b/src/SMAPI/Framework/ModLoading/Rewriters/TypeReferenceRewriter.cs
@@ -1,12 +1,11 @@
 using System;
 using Mono.Cecil;
-using StardewModdingAPI.Framework.ModLoading.Finders;
 using StardewModdingAPI.Framework.ModLoading.Framework;
 
 namespace StardewModdingAPI.Framework.ModLoading.Rewriters
 {
     /// <summary>Rewrites all references to a type.</summary>
-    internal class TypeReferenceRewriter : BaseTypeReferenceRewriter
+    internal class TypeReferenceRewriter : BaseInstructionHandler
     {
         /*********
         ** Fields
@@ -17,6 +16,9 @@ namespace StardewModdingAPI.Framework.ModLoading.Rewriters
         /// <summary>The new type to reference.</summary>
         private readonly Type ToType;
 
+        /// <summary>Get whether a matched type should be ignored.</summary>
+        private readonly Func<TypeReference, bool> ShouldIgnore;
+
 
         /*********
         ** Public methods
@@ -24,45 +26,29 @@ namespace StardewModdingAPI.Framework.ModLoading.Rewriters
         /// <summary>Construct an instance.</summary>
         /// <param name="fromTypeFullName">The full type name to which to find references.</param>
         /// <param name="toType">The new type to reference.</param>
-        /// <param name="shouldIgnore">A lambda which overrides a matched type.</param>
+        /// <param name="shouldIgnore">Get whether a matched type should be ignored.</param>
         public TypeReferenceRewriter(string fromTypeFullName, Type toType, Func<TypeReference, bool> shouldIgnore = null)
-            : base(new TypeFinder(fromTypeFullName, InstructionHandleResult.None, shouldIgnore), $"{fromTypeFullName} type")
+            : base($"{fromTypeFullName} type")
         {
             this.FromTypeName = fromTypeFullName;
             this.ToType = toType;
+            this.ShouldIgnore = shouldIgnore;
         }
 
-
-        /*********
-        ** Protected methods
-        *********/
-        /// <summary>Change a type reference if needed.</summary>
+        /// <summary>Rewrite a type reference if needed.</summary>
         /// <param name="module">The assembly module containing the instruction.</param>
-        /// <param name="type">The type to replace if it matches.</param>
-        /// <param name="set">Assign the new type reference.</param>
-        protected override bool RewriteIfNeeded(ModuleDefinition module, TypeReference type, Action<TypeReference> set)
+        /// <param name="type">The type definition to handle.</param>
+        /// <param name="replaceWith">Replaces the type reference with a new one.</param>
+        /// <returns>Returns whether the type was changed.</returns>
+        public override bool Handle(ModuleDefinition module, TypeReference type, Action<TypeReference> replaceWith)
         {
-            bool rewritten = false;
-
-            // current type
-            if (type.FullName == this.FromTypeName)
-            {
-                set(module.ImportReference(this.ToType));
-                return true;
-            }
-
-            // recurse into generic arguments
-            if (type is GenericInstanceType genericType)
-            {
-                for (int i = 0; i < genericType.GenericArguments.Count; i++)
-                    rewritten |= this.RewriteIfNeeded(module, genericType.GenericArguments[i], typeRef => genericType.GenericArguments[i] = typeRef);
-            }
-
-            // recurse into generic parameters (e.g. constraints)
-            for (int i = 0; i < type.GenericParameters.Count; i++)
-                rewritten |= this.RewriteIfNeeded(module, type.GenericParameters[i], typeRef => type.GenericParameters[i] = new GenericParameter(typeRef));
+            // check type reference
+            if (type.FullName != this.FromTypeName || this.ShouldIgnore?.Invoke(type) == true)
+                return false;
 
-            return rewritten;
+            // rewrite to new type
+            replaceWith(module.ImportReference(this.ToType));
+            return this.MarkRewritten();
         }
     }
 }