Merge pull request #32 from sepluginloader/dev

v1.10.0

Author: austinvaness

PluginLoader/Compiler/RoslynCompiler.cs

@@ -6,35 +6,59 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Reflection;
+using System.Text;
 
 namespace avaness.PluginLoader.Compiler
 {
     public class RoslynCompiler
     {
         private readonly List<Source> source = new List<Source>();
+        private bool debugBuild;
+
+        public RoslynCompiler(bool debugBuild = false)
+        {
+            this.debugBuild = debugBuild;
+        }
 
         public void Load(Stream s, string name)
         {
             MemoryStream mem = new MemoryStream();
             using (mem)
             {
                 s.CopyTo(mem);
-                source.Add(new Source(mem, name));
+                source.Add(new Source(mem, name, debugBuild));
             }
         }
 
-        public byte[] Compile(string assemblyName)
+        public byte[] Compile(string assemblyName, out byte[] symbols)
         {
+            symbols = null;
+
             CSharpCompilation compilation = CSharpCompilation.Create(
-               assemblyName,
-               syntaxTrees: source.Select(x => x.Tree),
-               references: RoslynReferences.EnumerateAllReferences(),
-               options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, optimizationLevel: OptimizationLevel.Release));
+                assemblyName,
+                syntaxTrees: source.Select(x => x.Tree),
+                references: RoslynReferences.EnumerateAllReferences(),
+                options: new CSharpCompilationOptions(
+                    OutputKind.DynamicallyLinkedLibrary, 
+                    optimizationLevel: debugBuild ? OptimizationLevel.Debug : OptimizationLevel.Release));
 
-            using (var ms = new MemoryStream())
+            using (MemoryStream pdb = new MemoryStream())
+            using (MemoryStream ms = new MemoryStream())
             {
                 // write IL code into memory
-                EmitResult result = compilation.Emit(ms);
+                EmitResult result;
+                if (debugBuild)
+                {
+                    result = compilation.Emit(ms, pdb,
+                        embeddedTexts: source.Select(x => x.Text),
+                        options: new EmitOptions(debugInformationFormat: DebugInformationFormat.PortablePdb, pdbFilePath: Path.ChangeExtension(assemblyName, "pdb")));
+                }
+                else
+                {
+                    result = compilation.Emit(ms);
+                }
+                 
                 if (!result.Success)
                 {
                     // handle exceptions
@@ -52,24 +76,38 @@ public byte[] Compile(string assemblyName)
                 }
                 else
                 {
-                    // load this 'virtual' DLL so that we can use
+                    if(debugBuild)
+                    {
+                        pdb.Seek(0, SeekOrigin.Begin);
+                        symbols = pdb.ToArray();
+                    }
+                    
                     ms.Seek(0, SeekOrigin.Begin);
                     return ms.ToArray();
                 }
             }
 
         }
 
-
         private class Source
         {
             public string Name { get; }
             public SyntaxTree Tree { get; }
+            public EmbeddedText Text { get; }
 
-            public Source(Stream s, string name)
+            public Source(Stream s, string name, bool includeText)
             {
                 Name = name;
-                Tree = CSharpSyntaxTree.ParseText(SourceText.From(s), new CSharpParseOptions(LanguageVersion.Latest));
+                SourceText source = SourceText.From(s, canBeEmbedded: includeText);
+                if (includeText)
+                {
+                    Text = EmbeddedText.FromSource(name, source);
+                    Tree = CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Latest), name);
+                }
+                else
+                {
+                    Tree = CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Latest));
+                }
             }
         }
     }

PluginLoader/Compiler/RoslynReferences.cs

@@ -17,7 +17,9 @@ public static void GenerateAssemblyList()
         {
             if (allReferences.Count > 0)
                 return;
-            
+
+            AssemblyName harmonyInfo = typeof(HarmonyLib.Harmony).Assembly.GetName();
+
             Stack<Assembly> loadedAssemblies = new Stack<Assembly>(AppDomain.CurrentDomain.GetAssemblies().Where(IsValidReference));
 
             StringBuilder sb = new StringBuilder();
@@ -32,6 +34,14 @@ public static void GenerateAssemblyList()
             {
                 foreach (Assembly a in loadedAssemblies)
                 {
+                    // Prevent other Harmony versions from being loaded
+                    AssemblyName name = a.GetName();
+                    if (name.Name == harmonyInfo.Name && name.Version != harmonyInfo.Version)
+                    {
+                        LogFile.WriteLine($"WARNING: Multiple Harmony assemblies are loaded. Plugin Loader is using {harmonyInfo} but found {name}");
+                        continue;
+                    }
+
                     AddAssemblyReference(a);
                     sb.AppendLine(a.FullName);
                 }
@@ -42,6 +52,13 @@ public static void GenerateAssemblyList()
 
                     foreach (AssemblyName name in a.GetReferencedAssemblies())
                     {
+                        // Prevent other Harmony versions from being loaded
+                        if (name.Name == harmonyInfo.Name && name.Version != harmonyInfo.Version)
+                        {
+                            LogFile.WriteLine($"WARNING: Multiple Harmony assemblies are loaded. Plugin Loader is using {harmonyInfo} but found {name}");
+                            continue;
+                        }
+
                         if (!ContainsReference(name) && TryLoadAssembly(name, out Assembly aRef) && IsValidReference(aRef))
                         {
                             AddAssemblyReference(aRef);

PluginLoader/Data/GitHubPlugin.cs

@@ -122,7 +122,7 @@ public byte[] CompileFromSource(Action<float> callback = null)
                 }
                 callback?.Invoke(1);
             }
-            return compiler.Compile(assemblyName + '_' + Path.GetRandomFileName());
+            return compiler.Compile(assemblyName + '_' + Path.GetRandomFileName(), out _);
         }
 
         private void CompileFromSource(RoslynCompiler compiler, ZipArchiveEntry entry)