Add basic support for netcore

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "dnlib"]
-	path = dnlib
-url=../dnlib.git

Confuser.Core/Confuser.Core.csproj

@@ -17,10 +17,7 @@
   <ItemGroup Label="Nuget Dependencies">
     <PackageReference Include="Microsoft.Win32.Registry" Version="4.*" />
     <PackageReference Include="System.Threading" Version="4.*" />
-  </ItemGroup>
-
-  <ItemGroup Label="Project Dependencies">
-    <ProjectReference Include="..\dnlib\src\dnlib.csproj" />
+    <PackageReference Include="dnlib" Version="3.3.2" />
   </ItemGroup>
 
 

Confuser.Core/ConfuserEngine.cs

@@ -94,11 +94,12 @@ static void RunInternal(ConfuserParameters parameters, CancellationToken token)
 				var asmResolver = new AssemblyResolver();
 				asmResolver.EnableTypeDefCache = true;
 				asmResolver.DefaultModuleContext = new ModuleContext(asmResolver);
+				asmResolver.EnableFrameworkRedirect = false;
 				context.Resolver = asmResolver;
 				context.BaseDirectory = Path.Combine(Environment.CurrentDirectory, context.Project.BaseDirectory.TrimEnd(Path.DirectorySeparatorChar) + Path.DirectorySeparatorChar);
 				context.OutputDirectory = Path.Combine(context.Project.BaseDirectory, context.Project.OutputDirectory.TrimEnd(Path.DirectorySeparatorChar) + Path.DirectorySeparatorChar);
 				foreach (string probePath in context.Project.ProbePaths)
-					asmResolver.PostSearchPaths.Insert(0, Path.Combine(context.BaseDirectory, probePath));
+					asmResolver.PreSearchPaths.Add(Path.Combine(context.BaseDirectory, probePath));
 
 				context.CheckCancellation();
 
@@ -384,6 +385,8 @@ static void EndModule(ConfuserContext context) {
 				if (!Path.IsPathRooted(output))
 					output = Path.Combine(Environment.CurrentDirectory, output);
 				output = Utils.GetRelativePath(output, context.BaseDirectory);
+				if (Path.IsPathRooted(output))
+					output = Path.GetFileName(output);
 			}
 			else {
 				output = context.CurrentModule.Name;

Confuser.Core/Helpers/InjectHelper.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using dnlib.DotNet;
 using dnlib.DotNet.Emit;
 
@@ -59,10 +60,9 @@ static FieldDefUser Clone(FieldDef origin) {
 		/// <returns>The new TypeDef.</returns>
 		static TypeDef PopulateContext(TypeDef typeDef, InjectContext ctx) {
 			TypeDef ret;
-			IDnlibDef existing;
-			if (!ctx.Map.TryGetValue(typeDef, out existing)) {
+			if (!ctx.MemberMap.TryGetValue(typeDef, out var existing)) {
 				ret = Clone(typeDef);
-				ctx.Map[typeDef] = ret;
+				ctx.MemberMap[typeDef] = ret;
 			}
 			else
 				ret = (TypeDef)existing;
@@ -71,10 +71,10 @@ static TypeDef PopulateContext(TypeDef typeDef, InjectContext ctx) {
 				ret.NestedTypes.Add(PopulateContext(nestedType, ctx));
 
 			foreach (MethodDef method in typeDef.Methods)
-				ret.Methods.Add((MethodDef)(ctx.Map[method] = Clone(method)));
+				ret.Methods.Add((MethodDef)(ctx.MemberMap[method] = Clone(method)));
 
 			foreach (FieldDef field in typeDef.Fields)
-				ret.Fields.Add((FieldDef)(ctx.Map[field] = Clone(field)));
+				ret.Fields.Add((FieldDef)(ctx.MemberMap[field] = Clone(field)));
 
 			return ret;
 		}
@@ -85,12 +85,12 @@ static TypeDef PopulateContext(TypeDef typeDef, InjectContext ctx) {
 		/// <param name="typeDef">The origin TypeDef.</param>
 		/// <param name="ctx">The injection context.</param>
 		static void CopyTypeDef(TypeDef typeDef, InjectContext ctx) {
-			var newTypeDef = (TypeDef)ctx.Map[typeDef];
+			var newTypeDef = (TypeDef)ctx.MemberMap[typeDef];
 
-			newTypeDef.BaseType = (ITypeDefOrRef)ctx.Importer.Import(typeDef.BaseType);
+			newTypeDef.BaseType = ctx.Importer.Import(typeDef.BaseType);
 
 			foreach (InterfaceImpl iface in typeDef.Interfaces)
-				newTypeDef.Interfaces.Add(new InterfaceImplUser((ITypeDefOrRef)ctx.Importer.Import(iface.Interface)));
+				newTypeDef.Interfaces.Add(new InterfaceImplUser(ctx.Importer.Import(iface.Interface)));
 		}
 
 		/// <summary>
@@ -99,7 +99,7 @@ static void CopyTypeDef(TypeDef typeDef, InjectContext ctx) {
 		/// <param name="methodDef">The origin MethodDef.</param>
 		/// <param name="ctx">The injection context.</param>
 		static void CopyMethodDef(MethodDef methodDef, InjectContext ctx) {
-			var newMethodDef = (MethodDef)ctx.Map[methodDef];
+			var newMethodDef = (MethodDef)ctx.MemberMap[methodDef];
 
 			newMethodDef.Signature = ctx.Importer.Import(methodDef.Signature);
 			newMethodDef.Parameters.UpdateParameterTypes();
@@ -151,7 +151,7 @@ static void CopyMethodDef(MethodDef methodDef, InjectContext ctx) {
 
 				foreach (ExceptionHandler eh in methodDef.Body.ExceptionHandlers)
 					newMethodDef.Body.ExceptionHandlers.Add(new ExceptionHandler(eh.HandlerType) {
-						CatchType = eh.CatchType == null ? null : (ITypeDefOrRef)ctx.Importer.Import(eh.CatchType),
+						CatchType = eh.CatchType == null ? null : ctx.Importer.Import(eh.CatchType),
 						TryStart = (Instruction)bodyMap[eh.TryStart],
 						TryEnd = (Instruction)bodyMap[eh.TryEnd],
 						HandlerStart = (Instruction)bodyMap[eh.HandlerStart],
@@ -169,7 +169,7 @@ static void CopyMethodDef(MethodDef methodDef, InjectContext ctx) {
 		/// <param name="fieldDef">The origin FieldDef.</param>
 		/// <param name="ctx">The injection context.</param>
 		static void CopyFieldDef(FieldDef fieldDef, InjectContext ctx) {
-			var newFieldDef = (FieldDef)ctx.Map[fieldDef];
+			var newFieldDef = (FieldDef)ctx.MemberMap[fieldDef];
 
 			newFieldDef.Signature = ctx.Importer.Import(fieldDef.Signature);
 		}
@@ -192,8 +192,8 @@ static void Copy(TypeDef typeDef, InjectContext ctx, bool copySelf) {
 
 			foreach (FieldDef field in typeDef.Fields)
 				CopyFieldDef(field, ctx);
-		}
-
+		}
+
 		/// <summary>
 		///     Injects the specified TypeDef to another module.
 		/// </summary>
@@ -204,9 +204,22 @@ public static TypeDef Inject(TypeDef typeDef, ModuleDef target) {
 			var ctx = new InjectContext(typeDef.Module, target);
 			PopulateContext(typeDef, ctx);
 			Copy(typeDef, ctx, true);
-			return (TypeDef)ctx.Map[typeDef];
-		}
-
+			return (TypeDef)ctx.MemberMap[typeDef];
+		}
+
+		/// <summary>
+		/// Imports a <see cref="MethodBase"/> as a <see cref="IMethod"/>. This will be either
+		/// a <see cref="MemberRef"/> or a <see cref="MethodSpec"/>.
+		/// </summary>
+		/// <param name="source">The source module.</param>
+		/// <param name="methodBase">The method</param>
+		/// <returns>The imported method or <c>null</c> if <paramref name="methodBase"/> is invalid
+		/// or if we failed to import the method</returns>
+		public static IMethod Import(ModuleDef target, MethodBase methodBase) {
+			var ctx = new InjectContext(null, target);
+			return ctx.Importer.Import(methodBase);
+		}
+
 		/// <summary>
 		///     Injects the specified MethodDef to another module.
 		/// </summary>
@@ -215,9 +228,9 @@ public static TypeDef Inject(TypeDef typeDef, ModuleDef target) {
 		/// <returns>The injected MethodDef.</returns>
 		public static MethodDef Inject(MethodDef methodDef, ModuleDef target) {
 			var ctx = new InjectContext(methodDef.Module, target);
-			ctx.Map[methodDef] = Clone(methodDef);
+			ctx.MemberMap[methodDef] = Clone(methodDef);
 			CopyMethodDef(methodDef, ctx);
-			return (MethodDef)ctx.Map[methodDef];
+			return (MethodDef)ctx.MemberMap[methodDef];
 		}
 
 		/// <summary>
@@ -229,20 +242,20 @@ public static MethodDef Inject(MethodDef methodDef, ModuleDef target) {
 		/// <returns>Injected members.</returns>
 		public static IEnumerable<IDnlibDef> Inject(TypeDef typeDef, TypeDef newType, ModuleDef target) {
 			var ctx = new InjectContext(typeDef.Module, target);
-			ctx.Map[typeDef] = newType;
+			ctx.MemberMap[typeDef] = newType;
 			PopulateContext(typeDef, ctx);
 			Copy(typeDef, ctx, false);
-			return ctx.Map.Values.Except(new[] { newType });
+			return ctx.MemberMap.Values.Except(new[] { newType }).OfType<IDnlibDef>();
 		}
 
 		/// <summary>
 		///     Context of the injection process.
 		/// </summary>
-		class InjectContext : ImportResolver {
+		class InjectContext : ImportMapper {
 			/// <summary>
 			///     The mapping of origin definitions to injected definitions.
 			/// </summary>
-			public readonly Dictionary<IDnlibDef, IDnlibDef> Map = new Dictionary<IDnlibDef, IDnlibDef>();
+			public readonly Dictionary<object, IMemberRef> MemberMap = new Dictionary<object, IMemberRef>();
 
 			/// <summary>
 			///     The module which source type originated from.
@@ -259,6 +272,10 @@ class InjectContext : ImportResolver {
 			/// </summary>
 			readonly Importer importer;
 
+			private readonly AssemblyRef netstandardRef;
+			private readonly AssemblyRef mscorlibRef;
+			private readonly AssemblyRef corelibRef;
+
 			/// <summary>
 			///     Initializes a new instance of the <see cref="InjectContext" /> class.
 			/// </summary>
@@ -267,8 +284,11 @@ class InjectContext : ImportResolver {
 			public InjectContext(ModuleDef module, ModuleDef target) {
 				OriginModule = module;
 				TargetModule = target;
-				importer = new Importer(target, ImporterOptions.TryToUseTypeDefs);
-				importer.Resolver = this;
+				importer = new Importer(target, ImporterOptions.TryToUseTypeDefs, new GenericParamContext(), this);
+
+				netstandardRef = TryResolveAssembly("netstandard");
+				mscorlibRef = TryResolveAssembly("mscorlib");
+				corelibRef = TryResolveAssembly("System.Private.CoreLib");
 			}
 
 			/// <summary>
@@ -277,27 +297,131 @@ public InjectContext(ModuleDef module, ModuleDef target) {
 			/// <value>The importer.</value>
 			public Importer Importer {
 				get { return importer; }
-			}
+			}
+
+			/// <inheritdoc />
+			public override ITypeDefOrRef Map(ITypeDefOrRef source) {
+				if (MemberMap.TryGetValue(source, out var result))
+					return (ITypeDefOrRef)result;
+
+				//HACK: for netcore
+				//System.Enviroment and System.AppDomain is in System.Runtime.Extensions/mscorlib/netstandard
+				//System.Runtime.InteropServices.Marshal is in System.Runtime.InteropServices/mscorlib/netstandard
+				if (source.IsTypeRef && OriginModule?.CorLibTypes.AssemblyRef != TargetModule.CorLibTypes.AssemblyRef) {
+					var sourceRef = (TypeRef)source;
+					TypeRef destRef = TryResolveType(sourceRef, TargetModule.CorLibTypes.AssemblyRef, false) ??
+						TryResolveType(sourceRef, netstandardRef, true) ??
+						TryResolveType(sourceRef, mscorlibRef, true) ??
+						TryResolveType(sourceRef, TryResolveAssembly(sourceRef.DefinitionAssembly.Name), false) ??
+						TryResolveType(sourceRef, corelibRef, false);
+
+					if (destRef != null) {
+						var stack = new Stack<IMDTokenProvider>(2);
+						stack.Push(destRef);
+						TypeRef cur = destRef;
+						do {
+							var scope = cur.ResolutionScope;
+							stack.Push(scope);
+							cur = scope as TypeRef;
+						} while (cur != null);
+						do {
+							TargetModule.UpdateRowId(stack.Pop());
+						} while (stack.Count > 0);
+					}
+
+					MemberMap[source] = destRef;
+					return destRef;
+				}
 
+				return null;
+			}
+
+			TypeRef TryResolveType(TypeRef sourceRef, AssemblyRef scope, bool followForward) {
+				if (scope == null)
+					return null;
+
+				var typeRef = Import2(sourceRef, scope);
+
+				var scopeDef = TargetModule.Context.AssemblyResolver.Resolve(typeRef.DefinitionAssembly, TargetModule);
+				if (scopeDef != null) {
+					if (scopeDef.TypeExists(typeRef))
+						return typeRef;
+					var sigComparer = new SigComparer(SigComparerOptions.DontCompareTypeScope);
+					var exportType = scopeDef.Modules.SelectMany(m => m.ExportedTypes).Where(et => sigComparer.Equals(et, typeRef)).FirstOrDefault();
+					if (exportType != null) {
+						if (followForward && (corelibRef == null || exportType.Implementation.Name != corelibRef.Name))
+							return exportType.ToTypeRef();
+						else
+							return typeRef;
+					}
+				}
+
+				return null;
+			}
+
+			AssemblyRef TryResolveAssembly(UTF8String name) {
+				return TargetModule.GetAssemblyRef(name) ?? TargetModule.Context.AssemblyResolver.Resolve(new AssemblyRefUser(name), TargetModule).ToAssemblyRef();
+			}
+
+			TypeRef Import2(TypeRef type, IResolutionScope scope) {
+				if (type is null)
+					return null;
+				TypeRef result;
+
+				var declaringType = type.DeclaringType;
+				if (!(declaringType is null))
+					result = new TypeRefUser(TargetModule, type.Namespace, type.Name, Import2(declaringType, scope));
+				else
+					result = new TypeRefUser(TargetModule, type.Namespace, type.Name, scope);
+
+				return result;
+			}
+
 			/// <inheritdoc />
-			public override TypeDef Resolve(TypeDef typeDef) {
-				if (Map.ContainsKey(typeDef))
-					return (TypeDef)Map[typeDef];
+			public override IMethod Map(MethodDef source) {
+				if (MemberMap.TryGetValue(source, out var result))
+					return (MethodDef)result;
 				return null;
 			}
 
 			/// <inheritdoc />
-			public override MethodDef Resolve(MethodDef methodDef) {
-				if (Map.ContainsKey(methodDef))
-					return (MethodDef)Map[methodDef];
+			public override IField Map(FieldDef source) {
+				if (MemberMap.ContainsKey(source))
+					return (FieldDef)MemberMap[source];
 				return null;
 			}
 
-			/// <inheritdoc />
-			public override FieldDef Resolve(FieldDef fieldDef) {
-				if (Map.ContainsKey(fieldDef))
-					return (FieldDef)Map[fieldDef];
-				return null;
+			public override TypeRef Map(Type source) {
+				if (MemberMap.TryGetValue(source, out var result))
+					return (TypeRef)result;
+
+				if (OriginModule?.CorLibTypes.AssemblyRef != TargetModule.CorLibTypes.AssemblyRef) {
+					var sourceRef = (TypeRef)TargetModule.Import(source);
+					TypeRef destRef = TryResolveType(sourceRef, TargetModule.CorLibTypes.AssemblyRef, false) ??
+						TryResolveType(sourceRef, netstandardRef, true) ??
+						TryResolveType(sourceRef, mscorlibRef, true) ??
+						TryResolveType(sourceRef, TryResolveAssembly(sourceRef.DefinitionAssembly.Name), false) ??
+						TryResolveType(sourceRef, corelibRef, false);
+
+					if (destRef != null) {
+						var stack = new Stack<IMDTokenProvider>(2);
+						stack.Push(destRef);
+						TypeRef cur = destRef;
+						do {
+							var scope = cur.ResolutionScope;
+							stack.Push(scope);
+							cur = scope as TypeRef;
+						} while (cur != null);
+						do {
+							TargetModule.UpdateRowId(stack.Pop());
+						} while (stack.Count > 0);
+
+						MemberMap[source] = destRef;
+						return destRef;
+					}
+				}
+
+				return null;
 			}
 		}
 	}