Refactor and cleanup for new Oxide.Compiler

Author: scorteanucosmin

src/AssemblyResolver.cs

@@ -1,30 +1,53 @@
 extern alias References;
-
+using System.IO;
 using Oxide.Core;
 using References::Mono.Cecil;
-using System.IO;
 
-namespace Oxide.CSharp
+namespace Oxide.CSharp;
+
+internal class AssemblyResolver : IAssemblyResolver
 {
-    internal class AssemblyResolver : DefaultAssemblyResolver
+    private readonly DefaultAssemblyResolver _resolver;
+    private readonly AssemblyDefinition _mscorlib;
+
+    public AssemblyResolver()
     {
-        internal readonly AssemblyDefinition mscorlib;
+        _resolver = new DefaultAssemblyResolver();
+        _resolver.AddSearchDirectory(Interface.Oxide.ExtensionDirectory);
+        _mscorlib = AssemblyDefinition.ReadAssembly(Path.Combine(Interface.Oxide.ExtensionDirectory, "mscorlib.dll"));
+    }
 
-        public AssemblyResolver() : base()
+    public AssemblyDefinition Resolve(AssemblyNameReference assemblyNameReference)
+    {
+        if (assemblyNameReference.Name == "System.Private.CoreLib")
         {
-            AddSearchDirectory(Interface.Oxide.ExtensionDirectory);
-            mscorlib = AssemblyDefinition.ReadAssembly(Path.Combine(Interface.Oxide.ExtensionDirectory, "mscorlib.dll"));
+            Interface.Oxide.RootLogger.WriteDebug(Core.Logging.LogType.Warning,
+                new Logging.LogEvent(50, "Resolve"), "Resolver",
+                "Redirecting reference to System.Private.CoreLib to mscorlib");
+
+            return _mscorlib;
         }
 
-        public override AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters)
+        return _resolver.Resolve(assemblyNameReference);
+    }
+
+    public AssemblyDefinition Resolve(AssemblyNameReference assemblyNameReference, ReaderParameters readerParameters)
+    {
+        if (assemblyNameReference.Name == "System.Private.CoreLib")
         {
-            if (name.Name == "System.Private.CoreLib")
-            {
-                Interface.Oxide.RootLogger.WriteDebug(Core.Logging.LogType.Warning, new Logging.LogEvent(50, "Resolve"), "Resolver", "Redirecting reference to System.Private.CoreLib to mscorlib");
-                return mscorlib;
-            }
+            Interface.Oxide.RootLogger.WriteDebug(Core.Logging.LogType.Warning,
+                new Logging.LogEvent(50, "Resolve"), "Resolver",
+                "Redirecting reference to System.Private.CoreLib to mscorlib");
 
-            return base.Resolve(name, parameters);
+            return _mscorlib;
         }
+
+        return _resolver.Resolve(assemblyNameReference, readerParameters);
+    }
+
+    public void Dispose()
+    {
+        _resolver.Dispose();
+        _mscorlib.Dispose();
     }
 }

src/CSharpPluginLoader.cs

@@ -7,7 +7,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
-using Oxide.Core.Libraries;
+using Oxide.CSharp.Common;
 
 namespace Oxide.Plugins
 {
@@ -35,19 +35,19 @@ public static CompilablePlugin GetCompilablePlugin(string directory, string name
 
         public override string FileExtension => ".cs";
 
-        private List<CompilablePlugin> compilationQueue = new List<CompilablePlugin>();
-        private CompilerService compiler;
+        private readonly List<CompilablePlugin> _compilationQueue = new List<CompilablePlugin>();
+        private readonly CompilerService _compiler;
 
         public CSharpPluginLoader(CSharpExtension extension)
         {
             Instance = this;
             CSharpPluginLoader.extension = extension;
-            compiler = new CompilerService(extension);
+            _compiler = new CompilerService(extension);
         }
 
         public void OnModLoaded()
         {
-            compiler.Precheck();
+            _compiler.Precheck();
 
             // Include references to all loaded game extensions and any assemblies they reference
             foreach (Core.Extensions.Extension extension in Interface.Oxide.GetAllExtensions())
@@ -78,7 +78,7 @@ public void OnModLoaded()
 
         public override IEnumerable<string> ScanDirectory(string directory)
         {
-            bool installed = compiler.Installed;
+            bool installed = _compiler.Installed;
             if (!installed)
             {
                 yield break;
@@ -126,7 +126,7 @@ public override Plugin Load(string directory, string name)
         /// <param name="name"></param>
         public override void Reload(string directory, string name)
         {
-            if (Regex.Match(directory, @"\\include\b", RegexOptions.IgnoreCase).Success)
+            if (Constants.IncludeRegex.Match(directory).Success)
             {
                 name = $"Oxide.{name}";
                 foreach (CompilablePlugin plugin in plugins.Values)
@@ -202,12 +202,14 @@ public void Load(CompilablePlugin plugin)
                     IEnumerable<string> loadingRequirements = plugin.Requires.Where(r => LoadingPlugins.Contains(r));
                     if (loadingRequirements.Any())
                     {
-                        Interface.Oxide.RootLogger.WriteDebug(LogType.Info, LogEvent.Compile, "CSharp", $"{plugin.Name} plugin is waiting for requirements to be loaded: {loadingRequirements.ToSentence()}");
+                        Interface.Oxide.RootLogger.WriteDebug(LogType.Info, LogEvent.Compile, "CSharp",
+                            $"{plugin.Name} plugin is waiting for requirements to be loaded: {loadingRequirements.ToSentence()}");
                     }
                     else
                     {
-                        Interface.Oxide.LogError($"{plugin.Name} plugin requires missing dependencies: {missingRequirements.ToSentence()}");
-                        PluginErrors[plugin.Name] = $"Missing dependencies: {missingRequirements.ToSentence()}";
+                        string sentence = missingRequirements.ToSentence();
+                        Interface.Oxide.LogError($"{plugin.Name} plugin requires missing dependencies: {sentence}");
+                        PluginErrors[plugin.Name] = $"Missing dependencies: {sentence}";
                         PluginLoadingCompleted(plugin);
                     }
                 }
@@ -239,15 +241,15 @@ public void CompilationRequested(CompilablePlugin plugin)
                 Compilation.Current.Add(plugin);
                 return;
             }
-            if (compilationQueue.Count < 1)
+            if (_compilationQueue.Count < 1)
             {
                 Interface.Oxide.NextTick(() =>
                 {
-                    CompileAssembly(compilationQueue.ToArray());
-                    compilationQueue.Clear();
+                    CompileAssembly(_compilationQueue.ToArray());
+                    _compilationQueue.Clear();
                 });
             }
-            compilationQueue.Add(plugin);
+            _compilationQueue.Add(plugin);
         }
 
         public void PluginLoadingStarted(CompilablePlugin plugin)
@@ -278,7 +280,7 @@ private void PluginLoadingCompleted(CompilablePlugin plugin)
 
         private void CompileAssembly(CompilablePlugin[] plugins)
         {
-            compiler.Compile(plugins, compilation =>
+            _compiler.Compile(plugins, compilation =>
             {
                 if (compilation.compiledAssembly == null)
                 {
@@ -316,6 +318,6 @@ private void CompileAssembly(CompilablePlugin[] plugins)
             });
         }
 
-        public void OnShutdown() => compiler.Stop(true, "framework shutting down");
+        public void OnShutdown() => _compiler.Stop(true, "framework shutting down");
     }
 }

src/Common/Constants.cs

@@ -0,0 +1,50 @@
+using System.Text.RegularExpressions;
+using Oxide.CompilerServices;
+
+namespace Oxide.CSharp.Common
+{
+    internal static class Constants
+    {
+        //TODO: Move to Oxide.Common & optimize this is a temporary solution
+        internal static readonly ISerializer Serializer = new Serializer();
+
+        internal const string CompilerDownloadUrl = "https://downloads.oxidemod.com/artifacts/Oxide.Compiler/{0}/";
+        internal const string CompilerBasicArguments = "-unsafe true --setting:Force true -ms true";
+
+        internal static readonly Regex FileErrorRegex = new Regex(@"^\[(?'Severity'\S+)\]\[(?'Code'\S+)\]\[(?'File'\S+)\] (?'Message'.+)$",
+            RegexOptions.Compiled);
+
+        internal static readonly Regex BlankLineRegex = new Regex(@"^\s*\{?\s*$",
+            RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+        internal static readonly Regex CustomAttributeRegex =
+            new Regex(@"^\s*\[", RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+        internal static readonly Regex MainPluginClassNameRegex =
+            new Regex(@"^\s*(?:public|private|protected|internal)?\s*class\s+(\S+)\s+\:\s+\S+Plugin\s*$",
+                RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+        internal static readonly Regex RequiresTextRegex = new Regex(@"^//\s*Requires:\s*(\S+?)(\.cs)?\s*$",
+            RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+        internal static readonly Regex ReferenceTextRegex = new Regex(@"^//\s*Reference:\s*(\S+)\s*$",
+            RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+        internal static readonly Regex ImplicitReferenceTextRegex =
+            new Regex(@"^\s*using\s+(Oxide\.(?:Core|Ext|Game)\.(?:[^\.]+))[^;]*;.*$",
+                RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+        internal static readonly Regex PluginNameRegex = new Regex(@"Oxide\\.[\\w]+\\.([\\w]+)",
+            RegexOptions.Compiled);
+
+        internal static readonly Regex NamespaceRegex = new Regex(@"^\s*namespace Oxide\.Plugins\s*(\{\s*)?$",
+            RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+        internal static readonly Regex PluginReferenceRegex = new Regex(@"^(Oxide\.(?:Ext|Game)\.(.+))$",
+            RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+        internal static readonly Regex IncludeRegex = new Regex(@"\\include\b", RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+        internal static readonly Regex SymbolEscapeRegex = new Regex(@"[^\w\d]", RegexOptions.Compiled);
+    }
+}