Merge 6b11b9d into e58a29a

Author: mkaring

Confuser.Core/ConfuserAssemblyResolver.cs

@@ -1,54 +1,114 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using dnlib.DotNet;
 
 namespace Confuser.Core {
 	internal sealed class ConfuserAssemblyResolver : IAssemblyResolver {
-		AssemblyResolver InternalResolver { get; }
+		internal AssemblyResolver InternalFuzzyResolver { get; } = new AssemblyResolver { FindExactMatch = false };
+		internal AssemblyResolver InternalExactResolver { get; } = new AssemblyResolver { FindExactMatch = true };
 
 		public bool EnableTypeDefCache {
-			get => InternalResolver.EnableTypeDefCache; 
-			set => InternalResolver.EnableTypeDefCache = value;
+			get => InternalFuzzyResolver.EnableTypeDefCache;
+			set {
+				InternalFuzzyResolver.EnableTypeDefCache = value;
+				InternalExactResolver.EnableTypeDefCache = value;
+			}
 		}
 
 		public ModuleContext DefaultModuleContext {
-			get => InternalResolver.DefaultModuleContext; 
-			set => InternalResolver.DefaultModuleContext = value;
+			get => InternalFuzzyResolver.DefaultModuleContext;
+			set {
+				InternalFuzzyResolver.DefaultModuleContext = value;
+				InternalExactResolver.DefaultModuleContext = value;
+			}
 		}
 
-		public IList<string> PostSearchPaths => InternalResolver.PostSearchPaths;
-
-		internal ConfuserAssemblyResolver() => 
-			InternalResolver = new AssemblyResolver();
+		public IList<string> PostSearchPaths => new TeeList(InternalFuzzyResolver.PostSearchPaths, InternalExactResolver.PostSearchPaths);
+		public IList<string> PreSearchPaths => new TeeList(InternalFuzzyResolver.PreSearchPaths, InternalExactResolver.PreSearchPaths);
 
 		/// <inheritdoc />
 		public AssemblyDef Resolve(IAssembly assembly, ModuleDef sourceModule) {
 			if (assembly is AssemblyDef assemblyDef)
 				return assemblyDef;
 
-			var cachedAssemblyDef = InternalResolver
-				.GetCachedAssemblies()
-				.FirstOrDefault(a => AssemblyNameComparer.NameAndPublicKeyTokenOnly.Equals(a, assembly));
-			if (!(cachedAssemblyDef is null))
-				return cachedAssemblyDef;
+			var resolvedAssemblyDef = InternalExactResolver.Resolve(assembly, sourceModule);
+			return resolvedAssemblyDef ?? InternalFuzzyResolver.Resolve(assembly, sourceModule);
+		}
+
+		public void Clear() {
+			InternalExactResolver.Clear();
+			InternalFuzzyResolver.Clear();
+		}
+
+		public IEnumerable<AssemblyDef> GetCachedAssemblies() => 
+			InternalExactResolver.GetCachedAssemblies().Concat(InternalFuzzyResolver.GetCachedAssemblies());
+
+		public void AddToCache(ModuleDefMD modDef) {
+			InternalExactResolver.AddToCache(modDef);
+			InternalFuzzyResolver.AddToCache(modDef);
+		}
+
+		private sealed class TeeList : IList<string> {
+			private readonly IList<IList<string>> _lists;
+
+			internal TeeList(params IList<string>[] lists) => _lists = lists;
+
+			/// <inheritdoc />
+			public IEnumerator<string> GetEnumerator() => _lists[0].GetEnumerator();
 
-			AssemblyDef resolvedAssemblyDef = null;
-			try {
-				InternalResolver.FindExactMatch = true;
-				resolvedAssemblyDef = InternalResolver.Resolve(assembly, sourceModule);
+			/// <inheritdoc />
+			IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+			/// <inheritdoc />
+			public void Add(string item) {
+				foreach (var list in _lists) 
+					list.Add(item);
 			}
-			finally {
-				InternalResolver.FindExactMatch = false;
+
+			/// <inheritdoc />
+			public void Clear() {
+				foreach (var list in _lists) 
+					list.Clear();
 			}
 
-			return resolvedAssemblyDef ?? InternalResolver.Resolve(assembly, sourceModule);
-		}
+			/// <inheritdoc />
+			public bool Contains(string item) => _lists[0].Contains(item);
+
+			/// <inheritdoc />
+			public void CopyTo(string[] array, int arrayIndex) => _lists[0].CopyTo(array, arrayIndex);
+
+			/// <inheritdoc />
+			public bool Remove(string item) =>
+				_lists.Aggregate(true, (current, list) => current | list.Remove(item));
+
+			/// <inheritdoc />
+			public int Count => _lists[0].Count;
 
-		public void Clear() => InternalResolver.Clear();
+			/// <inheritdoc />
+			public bool IsReadOnly => _lists[0].IsReadOnly;
 
-		public IEnumerable<AssemblyDef> GetCachedAssemblies() => InternalResolver.GetCachedAssemblies();
+			/// <inheritdoc />
+			public int IndexOf(string item) => _lists[0].IndexOf(item);
 
-		public void AddToCache(ModuleDefMD modDef) => InternalResolver.AddToCache(modDef);
+			/// <inheritdoc />
+			public void Insert(int index, string item) {
+				foreach (var list in _lists) 
+					list.Insert(index, item);
+			}
+
+			/// <inheritdoc />
+			public void RemoveAt(int index) {
+				foreach (var list in _lists) 
+					list.RemoveAt(index);
+			}
+
+			/// <inheritdoc />
+			public string this[int index] {
+				get => _lists[0][index];
+				set => _lists[0][index] = value;
+			}
+		}
 	}
 }