reorganise repo structure

5 files changed, 461 insertions, 0 deletions

diff --git a/src/SMAPI/Framework/ModLoading/Finders/EventFinder.cs b/src/SMAPI/Framework/ModLoading/Finders/EventFinder.cs
new file mode 100644
index 00000000..e4beb7a9
--- /dev/null
+++ b/src/SMAPI/Framework/ModLoading/Finders/EventFinder.cs
@@ -0,0 +1,82 @@
+using Mono.Cecil;
+using Mono.Cecil.Cil;
+
+namespace StardewModdingAPI.Framework.ModLoading.Finders
+{
+    /// <summary>Finds incompatible CIL instructions that reference a given event.</summary>
+    internal class EventFinder : IInstructionHandler
+    {
+        /*********
+        ** Properties
+        *********/
+        /// <summary>The full type name for which to find references.</summary>
+        private readonly string FullTypeName;
+
+        /// <summary>The event name for which to find references.</summary>
+        private readonly string EventName;
+
+        /// <summary>The result to return for matching instructions.</summary>
+        private readonly InstructionHandleResult Result;
+
+
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>A brief noun phrase indicating what the instruction finder matches.</summary>
+        public string NounPhrase { get; }
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="fullTypeName">The full type name for which to find references.</param>
+        /// <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)
+        {
+            this.FullTypeName = fullTypeName;
+            this.EventName = eventName;
+            this.Result = result;
+            this.NounPhrase = $"{fullTypeName}.{eventName} event";
+        }
+
+        /// <summary>Perform the predefined logic for a method if applicable.</summary>
+        /// <param name="module">The assembly module containing the instruction.</param>
+        /// <param name="method">The method definition containing the instruction.</param>
+        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
+        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
+        public virtual InstructionHandleResult Handle(ModuleDefinition module, MethodDefinition method, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        {
+            return InstructionHandleResult.None;
+        }
+
+        /// <summary>Perform the predefined logic for an instruction if applicable.</summary>
+        /// <param name="module">The assembly module containing the instruction.</param>
+        /// <param name="cil">The CIL processor.</param>
+        /// <param name="instruction">The instruction to handle.</param>
+        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
+        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
+        public virtual InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        {
+            return this.IsMatch(instruction)
+                ? this.Result
+                : InstructionHandleResult.None;
+        }
+
+
+        /*********
+        ** Protected methods
+        *********/
+        /// <summary>Get whether a CIL instruction matches.</summary>
+        /// <param name="instruction">The IL instruction.</param>
+        protected bool IsMatch(Instruction instruction)
+        {
+            MethodReference methodRef = RewriteHelper.AsMethodReference(instruction);
+            return
+                methodRef != null
+                && methodRef.DeclaringType.FullName == this.FullTypeName
+                && (methodRef.Name == "add_" + this.EventName || methodRef.Name == "remove_" + this.EventName);
+        }
+    }
+}
diff --git a/src/SMAPI/Framework/ModLoading/Finders/FieldFinder.cs b/src/SMAPI/Framework/ModLoading/Finders/FieldFinder.cs
new file mode 100644
index 00000000..00805815
--- /dev/null
+++ b/src/SMAPI/Framework/ModLoading/Finders/FieldFinder.cs
@@ -0,0 +1,82 @@
+using Mono.Cecil;
+using Mono.Cecil.Cil;
+
+namespace StardewModdingAPI.Framework.ModLoading.Finders
+{
+    /// <summary>Finds incompatible CIL instructions that reference a given field.</summary>
+    internal class FieldFinder : IInstructionHandler
+    {
+        /*********
+        ** Properties
+        *********/
+        /// <summary>The full type name for which to find references.</summary>
+        private readonly string FullTypeName;
+
+        /// <summary>The field name for which to find references.</summary>
+        private readonly string FieldName;
+
+        /// <summary>The result to return for matching instructions.</summary>
+        private readonly InstructionHandleResult Result;
+
+
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>A brief noun phrase indicating what the instruction finder matches.</summary>
+        public string NounPhrase { get; }
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="fullTypeName">The full type name for which to find references.</param>
+        /// <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)
+        {
+            this.FullTypeName = fullTypeName;
+            this.FieldName = fieldName;
+            this.Result = result;
+            this.NounPhrase = $"{fullTypeName}.{fieldName} field";
+        }
+
+        /// <summary>Perform the predefined logic for a method if applicable.</summary>
+        /// <param name="module">The assembly module containing the instruction.</param>
+        /// <param name="method">The method definition containing the instruction.</param>
+        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
+        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
+        public virtual InstructionHandleResult Handle(ModuleDefinition module, MethodDefinition method, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        {
+            return InstructionHandleResult.None;
+        }
+
+        /// <summary>Perform the predefined logic for an instruction if applicable.</summary>
+        /// <param name="module">The assembly module containing the instruction.</param>
+        /// <param name="cil">The CIL processor.</param>
+        /// <param name="instruction">The instruction to handle.</param>
+        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
+        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
+        public virtual InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        {
+            return this.IsMatch(instruction)
+                ? this.Result
+                : InstructionHandleResult.None;
+        }
+
+
+        /*********
+        ** 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;
+        }
+    }
+}
diff --git a/src/SMAPI/Framework/ModLoading/Finders/MethodFinder.cs b/src/SMAPI/Framework/ModLoading/Finders/MethodFinder.cs
new file mode 100644
index 00000000..5358f181
--- /dev/null
+++ b/src/SMAPI/Framework/ModLoading/Finders/MethodFinder.cs
@@ -0,0 +1,82 @@
+using Mono.Cecil;
+using Mono.Cecil.Cil;
+
+namespace StardewModdingAPI.Framework.ModLoading.Finders
+{
+    /// <summary>Finds incompatible CIL instructions that reference a given method.</summary>
+    internal class MethodFinder : IInstructionHandler
+    {
+        /*********
+        ** Properties
+        *********/
+        /// <summary>The full type name for which to find references.</summary>
+        private readonly string FullTypeName;
+
+        /// <summary>The method name for which to find references.</summary>
+        private readonly string MethodName;
+
+        /// <summary>The result to return for matching instructions.</summary>
+        private readonly InstructionHandleResult Result;
+
+
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>A brief noun phrase indicating what the instruction finder matches.</summary>
+        public string NounPhrase { get; }
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="fullTypeName">The full type name for which to find references.</param>
+        /// <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)
+        {
+            this.FullTypeName = fullTypeName;
+            this.MethodName = methodName;
+            this.Result = result;
+            this.NounPhrase = $"{fullTypeName}.{methodName} method";
+        }
+
+        /// <summary>Perform the predefined logic for a method if applicable.</summary>
+        /// <param name="module">The assembly module containing the instruction.</param>
+        /// <param name="method">The method definition containing the instruction.</param>
+        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
+        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
+        public virtual InstructionHandleResult Handle(ModuleDefinition module, MethodDefinition method, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        {
+            return InstructionHandleResult.None;
+        }
+
+        /// <summary>Perform the predefined logic for an instruction if applicable.</summary>
+        /// <param name="module">The assembly module containing the instruction.</param>
+        /// <param name="cil">The CIL processor.</param>
+        /// <param name="instruction">The instruction to handle.</param>
+        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
+        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
+        public InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        {
+            return this.IsMatch(instruction)
+                ? this.Result
+                : InstructionHandleResult.None;
+        }
+
+
+        /*********
+        ** Protected methods
+        *********/
+        /// <summary>Get whether a CIL instruction matches.</summary>
+        /// <param name="instruction">The IL instruction.</param>
+        protected bool IsMatch(Instruction instruction)
+        {
+            MethodReference methodRef = RewriteHelper.AsMethodReference(instruction);
+            return
+                methodRef != null
+                && methodRef.DeclaringType.FullName == this.FullTypeName
+                && methodRef.Name == this.MethodName;
+        }
+    }
+}
diff --git a/src/SMAPI/Framework/ModLoading/Finders/PropertyFinder.cs b/src/SMAPI/Framework/ModLoading/Finders/PropertyFinder.cs
new file mode 100644
index 00000000..e54c86cf
--- /dev/null
+++ b/src/SMAPI/Framework/ModLoading/Finders/PropertyFinder.cs
@@ -0,0 +1,82 @@
+using Mono.Cecil;
+using Mono.Cecil.Cil;
+
+namespace StardewModdingAPI.Framework.ModLoading.Finders
+{
+    /// <summary>Finds incompatible CIL instructions that reference a given property.</summary>
+    internal class PropertyFinder : IInstructionHandler
+    {
+        /*********
+        ** Properties
+        *********/
+        /// <summary>The full type name for which to find references.</summary>
+        private readonly string FullTypeName;
+
+        /// <summary>The property name for which to find references.</summary>
+        private readonly string PropertyName;
+
+        /// <summary>The result to return for matching instructions.</summary>
+        private readonly InstructionHandleResult Result;
+
+
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>A brief noun phrase indicating what the instruction finder matches.</summary>
+        public string NounPhrase { get; }
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="fullTypeName">The full type name for which to find references.</param>
+        /// <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)
+        {
+            this.FullTypeName = fullTypeName;
+            this.PropertyName = propertyName;
+            this.Result = result;
+            this.NounPhrase = $"{fullTypeName}.{propertyName} property";
+        }
+
+        /// <summary>Perform the predefined logic for a method if applicable.</summary>
+        /// <param name="module">The assembly module containing the instruction.</param>
+        /// <param name="method">The method definition containing the instruction.</param>
+        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
+        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
+        public virtual InstructionHandleResult Handle(ModuleDefinition module, MethodDefinition method, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        {
+            return InstructionHandleResult.None;
+        }
+
+        /// <summary>Perform the predefined logic for an instruction if applicable.</summary>
+        /// <param name="module">The assembly module containing the instruction.</param>
+        /// <param name="cil">The CIL processor.</param>
+        /// <param name="instruction">The instruction to handle.</param>
+        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
+        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
+        public virtual InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        {
+            return this.IsMatch(instruction)
+                ? this.Result
+                : InstructionHandleResult.None;
+        }
+
+
+        /*********
+        ** Protected methods
+        *********/
+        /// <summary>Get whether a CIL instruction matches.</summary>
+        /// <param name="instruction">The IL instruction.</param>
+        protected bool IsMatch(Instruction instruction)
+        {
+            MethodReference methodRef = RewriteHelper.AsMethodReference(instruction);
+            return
+                methodRef != null
+                && methodRef.DeclaringType.FullName == this.FullTypeName
+                && (methodRef.Name == "get_" + this.PropertyName || methodRef.Name == "set_" + this.PropertyName);
+        }
+    }
+}
diff --git a/src/SMAPI/Framework/ModLoading/Finders/TypeFinder.cs b/src/SMAPI/Framework/ModLoading/Finders/TypeFinder.cs
new file mode 100644
index 00000000..45349def
--- /dev/null
+++ b/src/SMAPI/Framework/ModLoading/Finders/TypeFinder.cs
@@ -0,0 +1,133 @@
+using System.Linq;
+using Mono.Cecil;
+using Mono.Cecil.Cil;
+
+namespace StardewModdingAPI.Framework.ModLoading.Finders
+{
+    /// <summary>Finds incompatible CIL instructions that reference a given type.</summary>
+    internal class TypeFinder : IInstructionHandler
+    {
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>The full type name for which to find references.</summary>
+        private readonly string FullTypeName;
+
+        /// <summary>The result to return for matching instructions.</summary>
+        private readonly InstructionHandleResult Result;
+
+
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>A brief noun phrase indicating what the instruction finder matches.</summary>
+        public string NounPhrase { get; }
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="fullTypeName">The full type name to match.</param>
+        /// <param name="result">The result to return for matching instructions.</param>
+        public TypeFinder(string fullTypeName, InstructionHandleResult result)
+        {
+            this.FullTypeName = fullTypeName;
+            this.Result = result;
+            this.NounPhrase = $"{fullTypeName} type";
+        }
+
+        /// <summary>Perform the predefined logic for a method if applicable.</summary>
+        /// <param name="module">The assembly module containing the instruction.</param>
+        /// <param name="method">The method definition containing the instruction.</param>
+        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
+        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
+        public virtual InstructionHandleResult Handle(ModuleDefinition module, MethodDefinition method, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        {
+            return 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 instruction to handle.</param>
+        /// <param name="assemblyMap">Metadata for mapping assemblies to the current platform.</param>
+        /// <param name="platformChanged">Whether the mod was compiled on a different platform.</param>
+        public virtual InstructionHandleResult Handle(ModuleDefinition module, ILProcessor cil, Instruction instruction, PlatformAssemblyMap assemblyMap, bool platformChanged)
+        {
+            return this.IsMatch(instruction)
+                ? this.Result
+                : InstructionHandleResult.None;
+        }
+
+
+        /*********
+        ** Protected methods
+        *********/
+        /// <summary>Get whether a CIL instruction matches.</summary>
+        /// <param name="method">The method deifnition.</param>
+        protected bool IsMatch(MethodDefinition method)
+        {
+            if (this.IsMatch(method.ReturnType))
+                return true;
+
+            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>
+        protected 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)
+            {
+                return
+                    this.IsMatch(methodRef.DeclaringType) // method on target class
+                    || this.IsMatch(methodRef.ReturnType) // method returns target class
+                    || methodRef.Parameters.Any(p => this.IsMatch(p.ParameterType)); // method parameters
+            }
+
+            return false;
+        }
+
+        /// <summary>Get whether a type reference matches the expected type.</summary>
+        /// <param name="type">The type to check.</param>
+        protected bool IsMatch(TypeReference type)
+        {
+            // root type
+            if (type.FullName == this.FullTypeName)
+                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;
+        }
+    }
+}