StardewValley
/
SMAPI
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rewrite assembly rewriting, merge Harmony rewriters (#711) 

This reduces duplication, decouples it from the assembly loader, and makes it more flexible to handle Harmony rewriting.
This commit is contained in:
Jesse Plamondon-Willard 2020-05-19 20:57:50 -04:00
parent f96dde00f9
commit 1838842bbc
No known key found for this signature in database
GPG Key ID: CF8B1456B3E29F49
22 changed files with 706 additions and 709 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

102
src/SMAPI/Framework/ModLoading/AssemblyLoader.cs
View File

@ -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))
{
// 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, type, replaceWith);
return rewritten;
},
rewriteInstruction: (instruction, cil, replaceWith) =>
{
bool rewritten = false;
foreach (IInstructionHandler handler in handlers)
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>

18
src/SMAPI/Framework/ModLoading/Finders/EventFinder.cs
View File

@ -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;
}

31
src/SMAPI/Framework/ModLoading/Finders/FieldFinder.cs
View File

@ -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;
}
}
}

18
src/SMAPI/Framework/ModLoading/Finders/MethodFinder.cs
View File

@ -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;
}

18
src/SMAPI/Framework/ModLoading/Finders/PropertyFinder.cs
View File

@ -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;
}

27
src/SMAPI/Framework/ModLoading/Finders/ReferenceToMemberWithUnexpectedTypeFinder.cs
View File

@ -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;
}

28
src/SMAPI/Framework/ModLoading/Finders/ReferenceToMissingMemberFinder.cs
View File

@ -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;
}

42
src/SMAPI/Framework/ModLoading/Finders/TypeAssemblyFinder.cs
View File

@ -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;
}
}
}

42
src/SMAPI/Framework/ModLoading/Finders/TypeFinder.cs
View File

@ -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;
}
}
}

66
src/SMAPI/Framework/ModLoading/Framework/BaseInstructionHandler.cs
View File

@ -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)
/// <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 a method if applicable.</summary>
/// <param name="module">The assembly module containing the instruction.</param>
/// <param name="method">The method definition to handle.</param>
/// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
/// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
public virtual InstructionHandleResult Handle(ModuleDefinition module, MethodDefinition method, PlatformAssemblyMap assemblyMap, bool platformChanged)
{
return InstructionHandleResult.None;
}
/// <summary>Perform the predefined logic for an instruction if applicable.</summary>
/// <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.NounPhrase = nounPhrase;
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()
{
return this.MarkFlag(InstructionHandleResult.Rewritten);
}
}
}

172
src/SMAPI/Framework/ModLoading/Framework/BaseTypeFinder.cs
View File

@ -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;
}
}
}

209
src/SMAPI/Framework/ModLoading/Framework/BaseTypeReferenceRewriter.cs
View File

@ -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;
}
}
}

260
src/SMAPI/Framework/ModLoading/Framework/RecursiveRewriter.cs Normal file
View File

@ -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;
}
}
}

24
src/SMAPI/Framework/ModLoading/RewriteHelper.cs → src/SMAPI/Framework/ModLoading/Framework/RewriteHelper.cs
View File

@ -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)

35
src/SMAPI/Framework/ModLoading/IInstructionHandler.cs
View File

@ -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);
/// <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 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);
/// <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);
}
}

37
src/SMAPI/Framework/ModLoading/Rewriters/FieldReplaceRewriter.cs
View File

@ -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();
}
}
}

42
src/SMAPI/Framework/ModLoading/Rewriters/FieldToPropertyRewriter.cs
View File

@ -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();
}
}
}

111
src/SMAPI/Framework/ModLoading/Rewriters/Harmony1AssemblyRewriter.cs
View File

@ -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));
case "HarmonyLib.Harmony":
toType = typeof(HarmonyInstanceMethods);
break;
case "HarmonyLib.AccessTools":
toType = typeof(AccessToolsMethods);
break;
default:
return false;
}
// map if there's a matching method
if (RewriteHelper.HasMatchingSignature(toType, methodRef))
{
methodRef.DeclaringType = module.ImportReference(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));
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);
}
}

40
src/SMAPI/Framework/ModLoading/Rewriters/MethodParentRewriter.cs
View File

@ -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);
}

35
src/SMAPI/Framework/ModLoading/Rewriters/StaticFieldToConstantRewriter.cs
View File

@ -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();
}

50
src/SMAPI/Framework/ModLoading/Rewriters/TypeReferenceRewriter.cs
View File

@ -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;
// check type reference
if (type.FullName != this.FromTypeName || this.ShouldIgnore?.Invoke(type) == true)
return 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));
return rewritten;
// rewrite to new type
replaceWith(module.ImportReference(this.ToType));
return this.MarkRewritten();
}
}
}

8
src/SMAPI/Metadata/InstructionMetadata.cs
View File

@ -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