summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/SMAPI/Framework/ModLoading/AssemblyLoader.cs100
-rw-r--r--src/SMAPI/Framework/ModLoading/Finders/EventFinder.cs18
-rw-r--r--src/SMAPI/Framework/ModLoading/Finders/FieldFinder.cs31
-rw-r--r--src/SMAPI/Framework/ModLoading/Finders/MethodFinder.cs18
-rw-r--r--src/SMAPI/Framework/ModLoading/Finders/PropertyFinder.cs18
-rw-r--r--src/SMAPI/Framework/ModLoading/Finders/ReferenceToMemberWithUnexpectedTypeFinder.cs27
-rw-r--r--src/SMAPI/Framework/ModLoading/Finders/ReferenceToMissingMemberFinder.cs28
-rw-r--r--src/SMAPI/Framework/ModLoading/Finders/TypeAssemblyFinder.cs42
-rw-r--r--src/SMAPI/Framework/ModLoading/Finders/TypeFinder.cs42
-rw-r--r--src/SMAPI/Framework/ModLoading/Framework/BaseInstructionHandler.cs66
-rw-r--r--src/SMAPI/Framework/ModLoading/Framework/BaseTypeFinder.cs172
-rw-r--r--src/SMAPI/Framework/ModLoading/Framework/BaseTypeReferenceRewriter.cs209
-rw-r--r--src/SMAPI/Framework/ModLoading/Framework/RecursiveRewriter.cs260
-rw-r--r--src/SMAPI/Framework/ModLoading/Framework/RewriteHelper.cs (renamed from src/SMAPI/Framework/ModLoading/RewriteHelper.cs)24
-rw-r--r--src/SMAPI/Framework/ModLoading/IInstructionHandler.cs35
-rw-r--r--src/SMAPI/Framework/ModLoading/Rewriters/FieldReplaceRewriter.cs37
-rw-r--r--src/SMAPI/Framework/ModLoading/Rewriters/FieldToPropertyRewriter.cs42
-rw-r--r--src/SMAPI/Framework/ModLoading/Rewriters/Harmony1AssemblyRewriter.cs107
-rw-r--r--src/SMAPI/Framework/ModLoading/Rewriters/MethodParentRewriter.cs40
-rw-r--r--src/SMAPI/Framework/ModLoading/Rewriters/StaticFieldToConstantRewriter.cs35
-rw-r--r--src/SMAPI/Framework/ModLoading/Rewriters/TypeReferenceRewriter.cs50
-rw-r--r--src/SMAPI/Metadata/InstructionMetadata.cs8
22 files changed, 703 insertions, 706 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();
}
}
}
diff --git a/src/SMAPI/Metadata/InstructionMetadata.cs b/src/SMAPI/Metadata/InstructionMetadata.cs
index d80f64e2..b7aad9da 100644
--- a/src/SMAPI/Metadata/InstructionMetadata.cs
+++ b/src/SMAPI/Metadata/InstructionMetadata.cs
@@ -25,21 +25,21 @@ namespace StardewModdingAPI.Metadata
*********/
/// <summary>Get rewriters which detect or fix incompatible CIL instructions in mod assemblies.</summary>
/// <param name="paranoidMode">Whether to detect paranoid mode issues.</param>
- public IEnumerable<IInstructionHandler> GetHandlers(bool paranoidMode)
+ /// <param name="platformChanged">Whether the assembly was rewritten for crossplatform compatibility.</param>
+ public IEnumerable<IInstructionHandler> GetHandlers(bool paranoidMode, bool platformChanged)
{
/****
** rewrite CIL to fix incompatible code
****/
// rewrite for crossplatform compatibility
- yield return new MethodParentRewriter(typeof(SpriteBatch), typeof(SpriteBatchMethods), onlyIfPlatformChanged: true);
+ if (platformChanged)
+ yield return new MethodParentRewriter(typeof(SpriteBatch), typeof(SpriteBatchMethods));
// rewrite for Stardew Valley 1.3
yield return new StaticFieldToConstantRewriter<int>(typeof(Game1), "tileSize", Game1.tileSize);
// rewrite for SMAPI 3.6 (Harmony 1.x => 2.0 update)
yield return new Harmony1AssemblyRewriter();
- yield return new MethodParentRewriter(typeof(HarmonyLib.Harmony), typeof(HarmonyInstanceMethods), onlyIfPlatformChanged: false, nounPhrase: Harmony1AssemblyRewriter.DefaultNounPhrase);
- yield return new MethodParentRewriter(typeof(HarmonyLib.AccessTools), typeof(AccessToolsMethods), onlyIfPlatformChanged: false, nounPhrase: Harmony1AssemblyRewriter.DefaultNounPhrase);
/****
** detect mod issues