diff options
Diffstat (limited to 'src/SMAPI/Framework/ModLoading/RewriteHelper.cs')
| -rw-r--r-- | src/SMAPI/Framework/ModLoading/RewriteHelper.cs | 188 |
1 files changed, 11 insertions, 177 deletions
diff --git a/src/SMAPI/Framework/ModLoading/RewriteHelper.cs b/src/SMAPI/Framework/ModLoading/RewriteHelper.cs index f8684cde..2f79809c 100644 --- a/src/SMAPI/Framework/ModLoading/RewriteHelper.cs +++ b/src/SMAPI/Framework/ModLoading/RewriteHelper.cs @@ -1,8 +1,6 @@ using System; -using System.Collections.Generic; using System.Linq; using System.Reflection; -using System.Text.RegularExpressions; using Mono.Cecil; using Mono.Cecil.Cil; @@ -14,8 +12,8 @@ namespace StardewModdingAPI.Framework.ModLoading /********* ** Properties *********/ - /// <summary>A pattern matching type name substrings to strip for display.</summary> - private static readonly Regex StripTypeNamePattern = new Regex(@"`\d+(?=<)", RegexOptions.Compiled); + /// <summary>The comparer which heuristically compares type definitions.</summary> + private static readonly TypeReferenceComparer TypeDefinitionComparer = new TypeReferenceComparer(); /********* @@ -68,6 +66,15 @@ namespace StardewModdingAPI.Framework.ModLoading return true; } + /// <summary>Determine whether two type IDs look like the same type, accounting for placeholder values such as !0.</summary> + /// <param name="typeA">The type ID to compare.</param> + /// <param name="typeB">The other type ID to compare.</param> + /// <returns>true if the type IDs look like the same type, false if not.</returns> + public static bool LooksLikeSameType(TypeReference typeA, TypeReference typeB) + { + return RewriteHelper.TypeDefinitionComparer.Equals(typeA, typeB); + } + /// <summary>Get whether a method definition matches the signature expected by a method reference.</summary> /// <param name="definition">The method definition.</param> /// <param name="reference">The method reference.</param> @@ -99,178 +106,5 @@ namespace StardewModdingAPI.Framework.ModLoading .GetMethods(BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public) .Any(method => RewriteHelper.HasMatchingSignature(method, reference)); } - - /// <summary>Determine whether this type ID has a placeholder such as !0.</summary> - /// <param name="typeID">The type to check.</param> - /// <returns>true if the type ID contains a placeholder, false if not.</returns> - public static bool HasPlaceholder(string typeID) - { - return typeID.Contains("!0"); - } - - /// <summary> returns whether this type ID is a placeholder, i.e., it begins with "!".</summary> - /// <param name="symbol">The symbol to validate.</param> - /// <returns>true if the symbol is a placeholder, false if not</returns> - public static bool IsPlaceholder(string symbol) - { - return symbol.StartsWith("!"); - } - - /// <summary>Determine whether two type IDs look like the same type, accounting for placeholder values such as !0.</summary> - /// <param name="a">The type ID to compare.</param> - /// <param name="b">The other type ID to compare.</param> - /// <returns>true if the type IDs look like the same type, false if not.</returns> - public static bool LooksLikeSameType(TypeReference a, TypeReference b) - { - string typeA = RewriteHelper.GetComparableTypeID(a); - string typeB = RewriteHelper.GetComparableTypeID(b); - - string placeholderType = "", actualType = ""; - - if (RewriteHelper.HasPlaceholder(typeA)) - { - placeholderType = typeA; - actualType = typeB; - } - else if (RewriteHelper.HasPlaceholder(typeB)) - { - placeholderType = typeB; - actualType = typeA; - } - else - return typeA == typeB; - - return RewriteHelper.PlaceholderTypeValidates(placeholderType, actualType); - } - - /// <summary>Get a unique string representation of a type.</summary> - /// <param name="type">The type reference.</param> - private static string GetComparableTypeID(TypeReference type) - { - return RewriteHelper.StripTypeNamePattern.Replace(type.FullName, ""); - } - - protected class SymbolLocation - { - public string symbol; - public int depth; - - public SymbolLocation(string symbol, int depth) - { - this.symbol = symbol; - this.depth = depth; - } - } - - private static List<char> symbolBoundaries = new List<char> { '<', '>', ',' }; - - /// <summary> Traverses and parses out symbols from a type which does not contain placeholder values.</summary> - /// <param name="type">The type to traverse.</param> - /// <param name="typeSymbols">A List in which to store the parsed symbols.</param> - private static void TraverseActualType(string type, List<SymbolLocation> typeSymbols) - { - int depth = 0; - string symbol = ""; - - foreach (char c in type) - { - if (RewriteHelper.symbolBoundaries.Contains(c)) - { - typeSymbols.Add(new SymbolLocation(symbol, depth)); - symbol = ""; - switch (c) - { - case '<': - depth++; - break; - case '>': - depth--; - break; - default: - break; - } - } - else - symbol += c; - } - } - - /// <summary> Determines whether two symbols in a type ID match, accounting for placeholders such as !0.</summary> - /// <param name="symbolA">A symbol in a typename which contains placeholders.</param> - /// <param name="symbolB">A symbol in a typename which does not contain placeholders.</param> - /// <param name="placeholderMap">A dictionary containing a mapping of placeholders to concrete types.</param> - /// <returns>true if the symbols match, false if not.</returns> - private static bool SymbolsMatch(SymbolLocation symbolA, SymbolLocation symbolB, Dictionary<string, string> placeholderMap) - { - if (symbolA.depth != symbolB.depth) - return false; - - if (!RewriteHelper.IsPlaceholder(symbolA.symbol)) - { - return symbolA.symbol == symbolB.symbol; - } - - if (placeholderMap.ContainsKey(symbolA.symbol)) - { - return placeholderMap[symbolA.symbol] == symbolB.symbol; - } - - placeholderMap[symbolA.symbol] = symbolB.symbol; - - return true; - } - - /// <summary> Determines whether a type which has placeholders correctly resolves to the concrete type provided. </summary> - /// <param name="type">A type containing placeholders such as !0.</param> - /// <param name="typeSymbols">The list of symbols extracted from the concrete type.</param> - /// <returns>true if the type resolves correctly, false if not.</returns> - private static bool PlaceholderTypeResolvesToActualType(string type, List<SymbolLocation> typeSymbols) - { - Dictionary<string, string> placeholderMap = new Dictionary<string, string>(); - - int depth = 0, symbolCount = 0; - string symbol = ""; - - foreach (char c in type) - { - if (symbolBoundaries.Contains(c)) - { - bool match = RewriteHelper.SymbolsMatch(new SymbolLocation(symbol, depth), typeSymbols[symbolCount], placeholderMap); - if (typeSymbols.Count <= symbolCount || - !match) - return false; - - symbolCount++; - symbol = ""; - switch (c) - { - case '<': - depth++; - break; - case '>': - depth--; - break; - default: - break; - } - } - else - symbol += c; - } - - return true; - } - - /// <summary>Determines whether a type with placeholders in it matches a type without placeholders.</summary> - /// <param name="placeholderType">The type with placeholders in it.</param> - /// <param name="actualType">The type without placeholders.</param> - /// <returns>true if the placeholder type can resolve to the actual type, false if not.</returns> - private static bool PlaceholderTypeValidates(string placeholderType, string actualType) - { - List<SymbolLocation> typeSymbols = new List<SymbolLocation>(); - - RewriteHelper.TraverseActualType(actualType, typeSymbols); - return PlaceholderTypeResolvesToActualType(placeholderType, typeSymbols); - } } } |