From f16e477fc22bf76c33d8860acda090a199a0dcdb Mon Sep 17 00:00:00 2001
From: Jesse Plamondon-Willard <Pathoschild@users.noreply.github.com>
Date: Wed, 6 May 2020 00:02:10 -0400
Subject: add base instruction handler (#711)

---
 .../Framework/ModLoading/Finders/EventFinder.cs    | 26 +++--------
 .../Framework/ModLoading/Finders/FieldFinder.cs    | 26 +++--------
 .../Framework/ModLoading/Finders/MethodFinder.cs   | 26 +++--------
 .../Framework/ModLoading/Finders/PropertyFinder.cs | 26 +++--------
 .../ReferenceToMemberWithUnexpectedTypeFinder.cs   | 25 +++--------
 .../Finders/ReferenceToMissingMemberFinder.cs      | 25 +++--------
 .../ModLoading/Framework/BaseInstructionHandler.cs | 51 ++++++++++++++++++++++
 .../ModLoading/Framework/BaseTypeFinder.cs         | 43 +++++++++---------
 .../Framework/BaseTypeReferenceRewriter.cs         | 38 +++++++---------
 .../Framework/ModLoading/IInstructionHandler.cs    |  4 +-
 .../ModLoading/Rewriters/MethodParentRewriter.cs   | 25 +++--------
 11 files changed, 124 insertions(+), 191 deletions(-)
 create mode 100644 src/SMAPI/Framework/ModLoading/Framework/BaseInstructionHandler.cs

(limited to 'src/SMAPI/Framework')

diff --git a/src/SMAPI/Framework/ModLoading/Finders/EventFinder.cs b/src/SMAPI/Framework/ModLoading/Finders/EventFinder.cs
index 898bafb4..1a7ae636 100644
--- a/src/SMAPI/Framework/ModLoading/Finders/EventFinder.cs
+++ b/src/SMAPI/Framework/ModLoading/Finders/EventFinder.cs
@@ -1,10 +1,11 @@
 using Mono.Cecil;
 using Mono.Cecil.Cil;
+using StardewModdingAPI.Framework.ModLoading.Framework;
 
 namespace StardewModdingAPI.Framework.ModLoading.Finders
 {
     /// <summary>Finds incompatible CIL instructions that reference a given event.</summary>
-    internal class EventFinder : IInstructionHandler
+    internal class EventFinder : BaseInstructionHandler
     {
         /*********
         ** Fields
@@ -19,13 +20,6 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
         private readonly InstructionHandleResult Result;
 
 
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>A brief noun phrase indicating what the instruction finder matches.</summary>
-        public string NounPhrase { get; }
-
-
         /*********
         ** Public methods
         *********/
@@ -34,30 +28,20 @@ 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")
         {
             this.FullTypeName = fullTypeName;
             this.EventName = eventName;
             this.Result = result;
-            this.NounPhrase = $"{fullTypeName}.{eventName} event";
-        }
-
-        /// <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 containing the instruction.</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)
-        {
-            return 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 instruction to handle.</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)
+        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
         {
             return this.IsMatch(instruction)
                 ? this.Result
diff --git a/src/SMAPI/Framework/ModLoading/Finders/FieldFinder.cs b/src/SMAPI/Framework/ModLoading/Finders/FieldFinder.cs
index 606ca8b7..9ae07916 100644
--- a/src/SMAPI/Framework/ModLoading/Finders/FieldFinder.cs
+++ b/src/SMAPI/Framework/ModLoading/Finders/FieldFinder.cs
@@ -1,10 +1,11 @@
 using Mono.Cecil;
 using Mono.Cecil.Cil;
+using StardewModdingAPI.Framework.ModLoading.Framework;
 
 namespace StardewModdingAPI.Framework.ModLoading.Finders
 {
     /// <summary>Finds incompatible CIL instructions that reference a given field.</summary>
-    internal class FieldFinder : IInstructionHandler
+    internal class FieldFinder : BaseInstructionHandler
     {
         /*********
         ** Fields
@@ -19,13 +20,6 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
         private readonly InstructionHandleResult Result;
 
 
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>A brief noun phrase indicating what the instruction finder matches.</summary>
-        public string NounPhrase { get; }
-
-
         /*********
         ** Public methods
         *********/
@@ -34,30 +28,20 @@ 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")
         {
             this.FullTypeName = fullTypeName;
             this.FieldName = fieldName;
             this.Result = result;
-            this.NounPhrase = $"{fullTypeName}.{fieldName} field";
-        }
-
-        /// <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 containing the instruction.</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)
-        {
-            return 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 instruction to handle.</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)
+        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
         {
             return this.IsMatch(instruction)
                 ? this.Result
diff --git a/src/SMAPI/Framework/ModLoading/Finders/MethodFinder.cs b/src/SMAPI/Framework/ModLoading/Finders/MethodFinder.cs
index 9ca246ff..75584f1f 100644
--- a/src/SMAPI/Framework/ModLoading/Finders/MethodFinder.cs
+++ b/src/SMAPI/Framework/ModLoading/Finders/MethodFinder.cs
@@ -1,10 +1,11 @@
 using Mono.Cecil;
 using Mono.Cecil.Cil;
+using StardewModdingAPI.Framework.ModLoading.Framework;
 
 namespace StardewModdingAPI.Framework.ModLoading.Finders
 {
     /// <summary>Finds incompatible CIL instructions that reference a given method.</summary>
-    internal class MethodFinder : IInstructionHandler
+    internal class MethodFinder : BaseInstructionHandler
     {
         /*********
         ** Fields
@@ -19,13 +20,6 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
         private readonly InstructionHandleResult Result;
 
 
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>A brief noun phrase indicating what the instruction finder matches.</summary>
-        public string NounPhrase { get; }
-
-
         /*********
         ** Public methods
         *********/
@@ -34,30 +28,20 @@ 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")
         {
             this.FullTypeName = fullTypeName;
             this.MethodName = methodName;
             this.Result = result;
-            this.NounPhrase = $"{fullTypeName}.{methodName} method";
-        }
-
-        /// <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 containing the instruction.</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)
-        {
-            return 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 instruction to handle.</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 InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
         {
             return this.IsMatch(instruction)
                 ? this.Result
diff --git a/src/SMAPI/Framework/ModLoading/Finders/PropertyFinder.cs b/src/SMAPI/Framework/ModLoading/Finders/PropertyFinder.cs
index 0677aa88..811420c5 100644
--- a/src/SMAPI/Framework/ModLoading/Finders/PropertyFinder.cs
+++ b/src/SMAPI/Framework/ModLoading/Finders/PropertyFinder.cs
@@ -1,10 +1,11 @@
 using Mono.Cecil;
 using Mono.Cecil.Cil;
+using StardewModdingAPI.Framework.ModLoading.Framework;
 
 namespace StardewModdingAPI.Framework.ModLoading.Finders
 {
     /// <summary>Finds incompatible CIL instructions that reference a given property.</summary>
-    internal class PropertyFinder : IInstructionHandler
+    internal class PropertyFinder : BaseInstructionHandler
     {
         /*********
         ** Fields
@@ -19,13 +20,6 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
         private readonly InstructionHandleResult Result;
 
 
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>A brief noun phrase indicating what the instruction finder matches.</summary>
-        public string NounPhrase { get; }
-
-
         /*********
         ** Public methods
         *********/
@@ -34,30 +28,20 @@ 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")
         {
             this.FullTypeName = fullTypeName;
             this.PropertyName = propertyName;
             this.Result = result;
-            this.NounPhrase = $"{fullTypeName}.{propertyName} property";
-        }
-
-        /// <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 containing the instruction.</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)
-        {
-            return 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 instruction to handle.</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)
+        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
         {
             return this.IsMatch(instruction)
                 ? this.Result
diff --git a/src/SMAPI/Framework/ModLoading/Finders/ReferenceToMemberWithUnexpectedTypeFinder.cs b/src/SMAPI/Framework/ModLoading/Finders/ReferenceToMemberWithUnexpectedTypeFinder.cs
index 459e3210..1029d350 100644
--- a/src/SMAPI/Framework/ModLoading/Finders/ReferenceToMemberWithUnexpectedTypeFinder.cs
+++ b/src/SMAPI/Framework/ModLoading/Finders/ReferenceToMemberWithUnexpectedTypeFinder.cs
@@ -2,12 +2,13 @@ using System.Collections.Generic;
 using System.Linq;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
+using StardewModdingAPI.Framework.ModLoading.Framework;
 
 namespace StardewModdingAPI.Framework.ModLoading.Finders
 {
     /// <summary>Finds references to a field, property, or method which returns a different type than the code expects.</summary>
     /// <remarks>This implementation is purely heuristic. It should never return a false positive, but won't detect all cases.</remarks>
-    internal class ReferenceToMemberWithUnexpectedTypeFinder : IInstructionHandler
+    internal class ReferenceToMemberWithUnexpectedTypeFinder : BaseInstructionHandler
     {
         /*********
         ** Fields
@@ -16,40 +17,24 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
         private readonly HashSet<string> ValidateReferencesToAssemblies;
 
 
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>A brief noun phrase indicating what the instruction finder matches.</summary>
-        public string NounPhrase { get; private set; } = "";
-
-
         /*********
         ** Public methods
         *********/
         /// <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: "")
         {
             this.ValidateReferencesToAssemblies = new HashSet<string>(validateReferencesToAssemblies);
         }
 
-        /// <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 containing the instruction.</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)
-        {
-            return 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 instruction to handle.</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)
+        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
         {
             // field reference
             FieldReference fieldRef = RewriteHelper.AsFieldReference(instruction);
diff --git a/src/SMAPI/Framework/ModLoading/Finders/ReferenceToMissingMemberFinder.cs b/src/SMAPI/Framework/ModLoading/Finders/ReferenceToMissingMemberFinder.cs
index 44b531a5..fefa88f4 100644
--- a/src/SMAPI/Framework/ModLoading/Finders/ReferenceToMissingMemberFinder.cs
+++ b/src/SMAPI/Framework/ModLoading/Finders/ReferenceToMissingMemberFinder.cs
@@ -2,12 +2,13 @@ using System.Collections.Generic;
 using System.Linq;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
+using StardewModdingAPI.Framework.ModLoading.Framework;
 
 namespace StardewModdingAPI.Framework.ModLoading.Finders
 {
     /// <summary>Finds references to a field, property, or method which no longer exists.</summary>
     /// <remarks>This implementation is purely heuristic. It should never return a false positive, but won't detect all cases.</remarks>
-    internal class ReferenceToMissingMemberFinder : IInstructionHandler
+    internal class ReferenceToMissingMemberFinder : BaseInstructionHandler
     {
         /*********
         ** Fields
@@ -16,40 +17,24 @@ namespace StardewModdingAPI.Framework.ModLoading.Finders
         private readonly HashSet<string> ValidateReferencesToAssemblies;
 
 
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>A brief noun phrase indicating what the instruction finder matches.</summary>
-        public string NounPhrase { get; private set; } = "";
-
-
         /*********
         ** Public methods
         *********/
         /// <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: "")
         {
             this.ValidateReferencesToAssemblies = new HashSet<string>(validateReferencesToAssemblies);
         }
 
-        /// <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 containing the instruction.</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)
-        {
-            return 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 instruction to handle.</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)
+        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
         {
             // field reference
             FieldReference fieldRef = RewriteHelper.AsFieldReference(instruction);
diff --git a/src/SMAPI/Framework/ModLoading/Framework/BaseInstructionHandler.cs b/src/SMAPI/Framework/ModLoading/Framework/BaseInstructionHandler.cs
new file mode 100644
index 00000000..10780d07
--- /dev/null
+++ b/src/SMAPI/Framework/ModLoading/Framework/BaseInstructionHandler.cs
@@ -0,0 +1,51 @@
+using Mono.Cecil;
+using Mono.Cecil.Cil;
+
+namespace StardewModdingAPI.Framework.ModLoading.Framework
+{
+    /// <summary>The base implementation for a CIL instruction handler or rewriter.</summary>
+    internal abstract class BaseInstructionHandler : IInstructionHandler
+    {
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>A brief noun phrase indicating what the handler matches.</summary>
+        public string NounPhrase { get; protected set; }
+
+
+        /*********
+        ** 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 virtual InstructionHandleResult Handle(ModuleDefinition module, MethodDefinition method, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        {
+            return 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 virtual InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        {
+            return InstructionHandleResult.None;
+        }
+
+
+        /*********
+        ** Protected methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="nounPhrase">A brief noun phrase indicating what the handler matches.</param>
+        protected BaseInstructionHandler(string nounPhrase)
+        {
+            this.NounPhrase = nounPhrase;
+        }
+    }
+}
diff --git a/src/SMAPI/Framework/ModLoading/Framework/BaseTypeFinder.cs b/src/SMAPI/Framework/ModLoading/Framework/BaseTypeFinder.cs
index b1547334..cfd87922 100644
--- a/src/SMAPI/Framework/ModLoading/Framework/BaseTypeFinder.cs
+++ b/src/SMAPI/Framework/ModLoading/Framework/BaseTypeFinder.cs
@@ -6,7 +6,7 @@ using Mono.Cecil.Cil;
 namespace StardewModdingAPI.Framework.ModLoading.Framework
 {
     /// <summary>Finds incompatible CIL type reference instructions.</summary>
-    internal abstract class BaseTypeFinder : IInstructionHandler
+    internal abstract class BaseTypeFinder : BaseInstructionHandler
     {
         /*********
         ** Accessors
@@ -18,33 +18,15 @@ namespace StardewModdingAPI.Framework.ModLoading.Framework
         private readonly InstructionHandleResult Result;
 
 
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>A brief noun phrase indicating what the instruction finder matches.</summary>
-        public string NounPhrase { get; }
-
-
         /*********
         ** Public 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>
-        public BaseTypeFinder(Func<TypeReference, bool> isMatch, InstructionHandleResult result, string nounPhrase)
-        {
-            this.IsMatchImpl = isMatch;
-            this.Result = result;
-            this.NounPhrase = nounPhrase;
-        }
-
         /// <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 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)
+        public override InstructionHandleResult Handle(ModuleDefinition module, MethodDefinition method, PlatformAssemblyMap assemblyMap, bool platformChanged)
         {
             return this.IsMatch(method)
                 ? this.Result
@@ -54,10 +36,10 @@ namespace StardewModdingAPI.Framework.ModLoading.Framework
         /// <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 instruction to handle.</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)
+        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
         {
             return this.IsMatch(instruction)
                 ? this.Result
@@ -127,5 +109,20 @@ namespace StardewModdingAPI.Framework.ModLoading.Framework
 
             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
index 55ce6b5a..5f38a30b 100644
--- a/src/SMAPI/Framework/ModLoading/Framework/BaseTypeReferenceRewriter.cs
+++ b/src/SMAPI/Framework/ModLoading/Framework/BaseTypeReferenceRewriter.cs
@@ -5,7 +5,7 @@ using Mono.Cecil.Cil;
 namespace StardewModdingAPI.Framework.ModLoading.Framework
 {
     /// <summary>Rewrites all references to a type.</summary>
-    internal abstract class BaseTypeReferenceRewriter : IInstructionHandler
+    internal abstract class BaseTypeReferenceRewriter : BaseInstructionHandler
     {
         /*********
         ** Fields
@@ -14,31 +14,15 @@ namespace StardewModdingAPI.Framework.ModLoading.Framework
         private readonly BaseTypeFinder Finder;
 
 
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>A brief noun phrase indicating what the handler matches.</summary>
-        public string NounPhrase { get; }
-
-
         /*********
         ** Public 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>
-        public BaseTypeReferenceRewriter(BaseTypeFinder finder, string nounPhrase)
-        {
-            this.Finder = finder;
-            this.NounPhrase = nounPhrase;
-        }
-
         /// <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 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 InstructionHandleResult Handle(ModuleDefinition module, MethodDefinition method, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        public override InstructionHandleResult Handle(ModuleDefinition module, MethodDefinition method, PlatformAssemblyMap assemblyMap, bool platformChanged)
         {
             bool rewritten = false;
 
@@ -78,10 +62,10 @@ namespace StardewModdingAPI.Framework.ModLoading.Framework
         /// <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 instruction to handle.</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 InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
         {
             if (!this.Finder.IsMatch(instruction))
                 return InstructionHandleResult.None;
@@ -114,9 +98,19 @@ namespace StardewModdingAPI.Framework.ModLoading.Framework
                 : InstructionHandleResult.None;
         }
 
+
         /*********
-        ** Private methods
+        ** 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>
diff --git a/src/SMAPI/Framework/ModLoading/IInstructionHandler.cs b/src/SMAPI/Framework/ModLoading/IInstructionHandler.cs
index 8830cc74..65b45b08 100644
--- a/src/SMAPI/Framework/ModLoading/IInstructionHandler.cs
+++ b/src/SMAPI/Framework/ModLoading/IInstructionHandler.cs
@@ -18,7 +18,7 @@ namespace StardewModdingAPI.Framework.ModLoading
         *********/
         /// <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 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);
@@ -26,7 +26,7 @@ namespace StardewModdingAPI.Framework.ModLoading
         /// <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 instruction to handle.</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);
diff --git a/src/SMAPI/Framework/ModLoading/Rewriters/MethodParentRewriter.cs b/src/SMAPI/Framework/ModLoading/Rewriters/MethodParentRewriter.cs
index c4c740b3..c6388295 100644
--- a/src/SMAPI/Framework/ModLoading/Rewriters/MethodParentRewriter.cs
+++ b/src/SMAPI/Framework/ModLoading/Rewriters/MethodParentRewriter.cs
@@ -2,11 +2,12 @@ using System;
 using System.Linq;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
+using StardewModdingAPI.Framework.ModLoading.Framework;
 
 namespace StardewModdingAPI.Framework.ModLoading.Rewriters
 {
     /// <summary>Rewrites method references from one parent type to another if the signatures match.</summary>
-    internal class MethodParentRewriter : IInstructionHandler
+    internal class MethodParentRewriter : BaseInstructionHandler
     {
         /*********
         ** Fields
@@ -21,13 +22,6 @@ namespace StardewModdingAPI.Framework.ModLoading.Rewriters
         private readonly bool OnlyIfPlatformChanged;
 
 
-        /*********
-        ** Accessors
-        *********/
-        /// <summary>A brief noun phrase indicating what the instruction finder matches.</summary>
-        public string NounPhrase { get; }
-
-
         /*********
         ** Public methods
         *********/
@@ -37,10 +31,10 @@ namespace StardewModdingAPI.Framework.ModLoading.Rewriters
         /// <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)
+            : base(nounPhrase ?? $"{fromType.Split('.').Last()} methods")
         {
             this.FromType = fromType;
             this.ToType = toType;
-            this.NounPhrase = nounPhrase ?? $"{fromType.Split('.').Last()} methods";
             this.OnlyIfPlatformChanged = onlyIfPlatformChanged;
         }
 
@@ -51,23 +45,14 @@ namespace StardewModdingAPI.Framework.ModLoading.Rewriters
         public MethodParentRewriter(Type fromType, Type toType, bool onlyIfPlatformChanged = false)
             : this(fromType.FullName, toType, onlyIfPlatformChanged) { }
 
-        /// <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 containing the instruction.</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 InstructionHandleResult Handle(ModuleDefinition module, MethodDefinition method, PlatformAssemblyMap assemblyMap, bool platformChanged)
-        {
-            return 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 instruction to handle.</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 InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        public override InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
         {
             if (!this.IsMatch(instruction, platformChanged))
                 return InstructionHandleResult.None;
-- 
cgit