Update compilation errors logic in order to support multiple errors

scorteanucosmin · scorteanucosmin · commit c3d530f2c8fc · 2026-02-14T20:49:37.000+02:00
diff --git a/src/CSharpPlugin.cs b/src/CSharpPlugin.cs
@@ -343,7 +343,7 @@ public override void HandleAddedToManager(PluginManager manager)
             catch (Exception ex)
             {
                 Interface.Oxide.LogException($"Failed to initialize plugin '{Name} v{Version}'", ex);
-                Loader.PluginErrors[Name] = ex.Message;
+                Loader.GetPluginErrors(Name).Add(ex.Message);
             }
         }
 
diff --git a/src/CSharpPluginLoader.cs b/src/CSharpPluginLoader.cs
@@ -209,7 +209,7 @@ public void Load(CompilablePlugin plugin)
                     {
                         string sentence = missingRequirements.ToSentence();
                         Interface.Oxide.LogError($"{plugin.Name} plugin requires missing dependencies: {sentence}");
-                        PluginErrors[plugin.Name] = $"Missing dependencies: {sentence}";
+                        GetPluginErrors(plugin.Name).Add($"Missing dependencies: {sentence}");
                         PluginLoadingCompleted(plugin);
                     }
                 }
@@ -287,31 +287,33 @@ private void CompileAssembly(CompilablePlugin[] plugins)
                     foreach (CompilablePlugin plugin in compilation.plugins)
                     {
                         plugin.OnCompilationFailed();
-                        PluginErrors[plugin.Name] = $"Failed to compile: {plugin.CompilerErrors}";
-                        Interface.Oxide.LogError($"Error while compiling {plugin.ScriptName}: {plugin.CompilerErrors}");
+                        string errors = plugin.CompilerErrors.JoinValues(Environment.NewLine);
+                        GetPluginErrors(plugin.Name).Add($"Failed to compile: {errors}"); // todo: 2 messages are added when compiling fails
+                        Interface.Oxide.LogError($"Error while compiling {plugin.ScriptName}: {errors}");
                     }
                 }
                 else
                 {
                     if (compilation.plugins.Count > 0)
                     {
-                        string[] compiledNames = compilation.plugins.Where(pl => string.IsNullOrEmpty(pl.CompilerErrors)).Select(pl => pl.Name).ToArray();
+                        string[] compiledNames = compilation.plugins.Where(pl => pl.CompilerErrors.Count == 0).Select(pl => pl.Name).ToArray();
                         string verb = compiledNames.Length > 1 ? "were" : "was";
                         Interface.Oxide.LogInfo($"{compiledNames.ToSentence()} {verb} compiled successfully in {Math.Round(compilation.duration * 1000f)}ms");
                     }
 
                     foreach (CompilablePlugin plugin in compilation.plugins)
                     {
-                        if (plugin.CompilerErrors == null)
+                        if (plugin.CompilerErrors.Count == 0)
                         {
                             Interface.Oxide.UnloadPlugin(plugin.Name);
                             plugin.OnCompilationSucceeded(compilation.compiledAssembly);
                         }
                         else
                         {
                             plugin.OnCompilationFailed();
-                            PluginErrors[plugin.Name] = $"Failed to compile: {plugin.CompilerErrors}";
-                            Interface.Oxide.LogError($"Error while compiling {plugin.ScriptName}: {plugin.CompilerErrors}");
+                            string errors = plugin.CompilerErrors.JoinValues(Environment.NewLine);
+                            GetPluginErrors(plugin.Name).Add($"Failed to compile: {errors}");
+                            Interface.Oxide.LogError($"Error while compiling {plugin.ScriptName}: {errors}");
                         }
                     }
                 }
diff --git a/src/CompilableFile.cs b/src/CompilableFile.cs
@@ -24,7 +24,7 @@ public class CompilableFile
         public HashSet<string> Requires = new HashSet<string>();
         public HashSet<string> References = new HashSet<string>();
         public HashSet<string> IncludePaths = new HashSet<string>();
-        public string CompilerErrors;
+        public readonly HashSet<string> CompilerErrors;
         public CompiledAssembly CompiledAssembly;
         public DateTime LastModifiedAt;
         public DateTime LastCachedScriptAt;
@@ -47,6 +47,7 @@ public CompilableFile(CSharpExtension extension, CSharpPluginLoader loader, stri
             ScriptName = name;
             ScriptPath = Path.Combine(Directory, $"{ScriptName}.cs");
             Name = Regex.Replace(ScriptName, "_", "");
+            CompilerErrors = new HashSet<string>();
             CheckLastModificationTime();
         }
 
@@ -124,7 +125,7 @@ internal void OnCompilationFailed()
         internal void OnCompilationTimeout()
         {
             Interface.Oxide.LogError("Timed out waiting for plugin to be compiled: " + Name);
-            CompilerErrors = "Timed out waiting for compilation";
+            CompilerErrors.Add("Timed out waiting for compilation");
             OnCompilationFailed();
         }
 
diff --git a/src/CompilablePlugin.cs b/src/CompilablePlugin.cs
@@ -38,9 +38,9 @@ internal void LoadPlugin(Action<CSharpPlugin> callback = null)
                     return;
                 }
 
-                if (CompilerErrors != null)
+                if (CompilerErrors.Count > 0)
                 {
-                    InitFailed($"Unable to load {ScriptName}. {CompilerErrors}");
+                    InitFailed($"Unable to load {ScriptName}. {CompilerErrors.JoinValues(Environment.NewLine)}");
                     return;
                 }
 
@@ -148,7 +148,7 @@ protected override void InitFailed(string message = null)
             }
             Interface.Oxide.LogInfo("Rolling back plugin to last good version: {0}", ScriptName);
             CompiledAssembly = LastGoodAssembly;
-            CompilerErrors = null;
+            CompilerErrors.Clear();
             LoadPlugin();
         }
     }
diff --git a/src/Compilation.cs b/src/Compilation.cs
@@ -45,7 +45,7 @@ internal Compilation(int id, Action<Compilation> callback, CompilablePlugin[] pl
 
             foreach (CompilablePlugin plugin in plugins)
             {
-                plugin.CompilerErrors = null;
+                plugin.CompilerErrors.Clear();
                 plugin.OnCompilationStarted();
             }
 
@@ -77,7 +77,7 @@ internal void Add(CompilablePlugin plugin)
             }
 
             plugin.Loader.PluginLoadingStarted(plugin);
-            plugin.CompilerErrors = null;
+            plugin.CompilerErrors.Clear();
             plugin.OnCompilationStarted();
 
             foreach (Core.Plugins.Plugin pl in Interface.Oxide.RootPluginManager.GetPlugins().Where(pl => pl is CSharpPlugin))
@@ -100,7 +100,7 @@ internal bool IncludesRequiredPlugin(string name)
             }
 
             CompilablePlugin compilablePlugin = plugins.SingleOrDefault(pl => pl.Name == name);
-            return compilablePlugin != null && compilablePlugin.CompilerErrors == null;
+            return compilablePlugin is { CompilerErrors.Count: 0 };
         }
 
         internal void Prepare(Action callback)
@@ -221,7 +221,7 @@ private void PreparseScript(CompilablePlugin plugin)
                 if (line.IndexOf("namespace uMod.Plugins", StringComparison.InvariantCultureIgnoreCase) >= 0)
                 {
                     Interface.Oxide.LogError($"Plugin {plugin.ScriptName}.cs is a uMod plugin, not an Oxide plugin. Please downgrade to the Oxide version if available.");
-                    plugin.CompilerErrors = $"Plugin {plugin.ScriptName}.cs is a uMod plugin, not an Oxide plugin. Please downgrade to the Oxide version if available.";
+                    plugin.CompilerErrors.Add($"Plugin {plugin.ScriptName}.cs is a uMod plugin, not an Oxide plugin. Please downgrade to the Oxide version if available.");
                     RemovePlugin(plugin);
                     return;
                 }
@@ -259,7 +259,7 @@ private void PreparseScript(CompilablePlugin plugin)
                     if (className != plugin.Name)
                     {
                         Interface.Oxide.LogError($"Plugin filename {plugin.ScriptName}.cs must match the main class {className} (should be {className}.cs)");
-                        plugin.CompilerErrors = $"Plugin filename {plugin.ScriptName}.cs must match the main class {className} (should be {className}.cs)";
+                        plugin.CompilerErrors.Add($"Plugin filename {plugin.ScriptName}.cs must match the main class {className} (should be {className}.cs)");
                         RemovePlugin(plugin);
                     }
 
@@ -275,7 +275,7 @@ private void PreparseScript(CompilablePlugin plugin)
                     if (!File.Exists(Path.Combine(plugin.Directory, dependencyName + ".cs")))
                     {
                         Interface.Oxide.LogError($"{plugin.Name} plugin requires missing dependency: {dependencyName}");
-                        plugin.CompilerErrors = $"Missing dependency: {dependencyName}";
+                        plugin.CompilerErrors.Add($"Missing dependency: {dependencyName}");
                         RemovePlugin(plugin);
                         return;
                     }
@@ -360,7 +360,7 @@ private void ResolveReferences(CompilablePlugin plugin)
 
                 string message = $"{fullName} is referenced by {plugin.Name} plugin but is not loaded";
                 Interface.Oxide.LogError(message);
-                plugin.CompilerErrors = message;
+                plugin.CompilerErrors.Add(message);
                 RemovePlugin(plugin);
             }
         }
@@ -401,7 +401,7 @@ private void AddReference(CompilablePlugin plugin, string assemblyNameString)
                 }
 
                 Interface.Oxide.LogError($"Assembly referenced by {plugin.Name} plugin does not exist: {assemblyNameString}.dll");
-                plugin.CompilerErrors = $"Referenced assembly does not exist: {assemblyNameString}";
+                plugin.CompilerErrors.Add($"Referenced assembly does not exist: {assemblyNameString}");
                 RemovePlugin(plugin);
                 return;
             }
@@ -414,7 +414,7 @@ private void AddReference(CompilablePlugin plugin, string assemblyNameString)
             catch (FileNotFoundException)
             {
                 Interface.Oxide.LogError($"Assembly referenced by {plugin.Name} plugin is invalid: {assemblyNameString}.dll");
-                plugin.CompilerErrors = $"Referenced assembly is invalid: {assemblyNameString}";
+                plugin.CompilerErrors.Add($"Referenced assembly is invalid: {assemblyNameString}");
                 RemovePlugin(plugin);
                 return;
             }
@@ -466,7 +466,7 @@ private bool CacheScriptLines(CompilablePlugin plugin)
                     if (!File.Exists(plugin.ScriptPath))
                     {
                         Interface.Oxide.LogWarning("Script no longer exists: {0}", plugin.Name);
-                        plugin.CompilerErrors = "Plugin file was deleted";
+                        plugin.CompilerErrors.Add("Plugin file was deleted");
                         RemovePlugin(plugin);
                         return false;
                     }
diff --git a/src/CompiledAssembly.cs b/src/CompiledAssembly.cs
@@ -124,7 +124,7 @@ private void ValidateAssembly(Action<byte[], byte[]> callback)
                     AssemblyDefinition assemblyDefinition = AssemblyDefinition.ReadAssembly(assemblyStream, readerParameters);
 
                     int foundPlugins = 0;
-                    int totalPlugins = CompilablePlugins.Count(p => p.CompilerErrors == null);
+                    int totalPlugins = CompilablePlugins.Count(p => p.CompilerErrors.Count == 0);
                     for (int i = 0; i < assemblyDefinition.MainModule.Types.Count; i++)
                     {
                         if (foundPlugins == totalPlugins)
@@ -159,10 +159,7 @@ private void ValidateAssembly(Action<byte[], byte[]> callback)
                                         $"User defined constructors are not supported. Please remove the constructor from {typeDefinition.Name}.cs"); // Should be allowed
 
                                     CompilablePlugin plugin = CompilablePlugins.SingleOrDefault(p => p.Name == typeDefinition.Name);
-                                    if (plugin != null)
-                                    {
-                                        plugin.CompilerErrors = "Primary constructor in main class must be public";
-                                    }
+                                    plugin?.CompilerErrors.Add("Primary constructor in main class must be public");
                                 }
                                 else
                                 {
diff --git a/src/CompilerService.cs b/src/CompilerService.cs
@@ -326,14 +326,13 @@ private void OnMessageReceived(CompilerMessage message)
                             string[] missingRequirementsArray = missingRequirements.ToArray();
                             if (missingRequirementsArray.Length > 0)
                             {
-                                compilablePlugin.CompilerErrors = $"Missing dependencies: {string.Join(",", missingRequirementsArray)}";
+                                compilablePlugin.CompilerErrors.Add($"Missing dependencies: {string.Join(",", missingRequirementsArray)}");
 
                                 Log(LogType.Error, $"[{error.File}] Missing dependencies: {string.Join(",", missingRequirementsArray)}");
                             }
                             else
                             {
-                                // TODO: Allow multiple errors
-                                compilablePlugin.CompilerErrors = error.Message;
+                                compilablePlugin.CompilerErrors.Add(error.Message);
 
                                 Log(LogType.Error, $"[{error.File}] {error.Message}");
                             }
@@ -370,7 +369,7 @@ private void OnMessageReceived(CompilerMessage message)
 
                     foreach (CompilablePlugin p in compilation.plugins)
                     {
-                        p.CompilerErrors = errorMessage;
+                        p.CompilerErrors.Add(errorMessage);
                     }
 
                     compilation.Completed();
@@ -558,7 +557,7 @@ private void EnqueueCompilation(Compilation compilation)
                 string name = Path.GetFileName(plugin.ScriptPath ?? plugin.ScriptName);
                 if (plugin.ScriptSource == null || plugin.ScriptSource.Length == 0)
                 {
-                    plugin.CompilerErrors = "No data contained in .cs file";
+                    plugin.CompilerErrors.Add("No data contained in .cs file");
                     Log(LogType.Error, $"Ignoring plugin {name}, file is empty");
                     continue;
                 }
@@ -629,7 +628,7 @@ private void OnCompilerFailed(string reason)
             {
                 foreach (CompilablePlugin plugin in compilation.plugins)
                 {
-                    plugin.CompilerErrors = reason;
+                    plugin.CompilerErrors.Add(reason);
                 }
 
                 compilation.Completed();

Original file line number	Diff line number	Diff line change
`@@ -343,7 +343,7 @@ public override void HandleAddedToManager(PluginManager manager)`
`343`	`343`	`catch (Exception ex)`
`344`	`344`	`{`
`345`	`345`	`Interface.Oxide.LogException($"Failed to initialize plugin '{Name} v{Version}'", ex);`
`346`		`- Loader.PluginErrors[Name] = ex.Message;`
	`346`	`+ Loader.GetPluginErrors(Name).Add(ex.Message);`
`347`	`347`	`}`
`348`	`348`	`}`
`349`	`349`
Original file line number	Diff line number	Diff line change
`@@ -209,7 +209,7 @@ public void Load(CompilablePlugin plugin)`
`209`	`209`	`{`
`210`	`210`	`string sentence = missingRequirements.ToSentence();`
`211`	`211`	`Interface.Oxide.LogError($"{plugin.Name} plugin requires missing dependencies: {sentence}");`
`212`		`- PluginErrors[plugin.Name] = $"Missing dependencies: {sentence}";`
	`212`	`+ GetPluginErrors(plugin.Name).Add($"Missing dependencies: {sentence}");`
`213`	`213`	`PluginLoadingCompleted(plugin);`
`214`	`214`	`}`
`215`	`215`	`}`
`@@ -287,31 +287,33 @@ private void CompileAssembly(CompilablePlugin[] plugins)`
`287`	`287`	`foreach (CompilablePlugin plugin in compilation.plugins)`
`288`	`288`	`{`
`289`	`289`	`plugin.OnCompilationFailed();`
`290`		`- PluginErrors[plugin.Name] = $"Failed to compile: {plugin.CompilerErrors}";`
`291`		`- Interface.Oxide.LogError($"Error while compiling {plugin.ScriptName}: {plugin.CompilerErrors}");`
	`290`	`+ string errors = plugin.CompilerErrors.JoinValues(Environment.NewLine);`
	`291`	`+ GetPluginErrors(plugin.Name).Add($"Failed to compile: {errors}"); // todo: 2 messages are added when compiling fails`
	`292`	`+ Interface.Oxide.LogError($"Error while compiling {plugin.ScriptName}: {errors}");`
`292`	`293`	`}`
`293`	`294`	`}`
`294`	`295`	`else`
`295`	`296`	`{`
`296`	`297`	`if (compilation.plugins.Count > 0)`
`297`	`298`	`{`
`298`		`- string[] compiledNames = compilation.plugins.Where(pl => string.IsNullOrEmpty(pl.CompilerErrors)).Select(pl => pl.Name).ToArray();`
	`299`	`+ string[] compiledNames = compilation.plugins.Where(pl => pl.CompilerErrors.Count == 0).Select(pl => pl.Name).ToArray();`
`299`	`300`	`string verb = compiledNames.Length > 1 ? "were" : "was";`
`300`	`301`	`Interface.Oxide.LogInfo($"{compiledNames.ToSentence()} {verb} compiled successfully in {Math.Round(compilation.duration * 1000f)}ms");`
`301`	`302`	`}`
`302`	`303`
`303`	`304`	`foreach (CompilablePlugin plugin in compilation.plugins)`
`304`	`305`	`{`
`305`		`- if (plugin.CompilerErrors == null)`
	`306`	`+ if (plugin.CompilerErrors.Count == 0)`
`306`	`307`	`{`
`307`	`308`	`Interface.Oxide.UnloadPlugin(plugin.Name);`
`308`	`309`	`plugin.OnCompilationSucceeded(compilation.compiledAssembly);`
`309`	`310`	`}`
`310`	`311`	`else`
`311`	`312`	`{`
`312`	`313`	`plugin.OnCompilationFailed();`
`313`		`- PluginErrors[plugin.Name] = $"Failed to compile: {plugin.CompilerErrors}";`
`314`		`- Interface.Oxide.LogError($"Error while compiling {plugin.ScriptName}: {plugin.CompilerErrors}");`
	`314`	`+ string errors = plugin.CompilerErrors.JoinValues(Environment.NewLine);`
	`315`	`+ GetPluginErrors(plugin.Name).Add($"Failed to compile: {errors}");`
	`316`	`+ Interface.Oxide.LogError($"Error while compiling {plugin.ScriptName}: {errors}");`
`315`	`317`	`}`
`316`	`318`	`}`
`317`	`319`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,9 +38,9 @@ internal void LoadPlugin(Action<CSharpPlugin> callback = null)`
`38`	`38`	`return;`
`39`	`39`	`}`
`40`	`40`
`41`		`- if (CompilerErrors != null)`
	`41`	`+ if (CompilerErrors.Count > 0)`
`42`	`42`	`{`
`43`		`- InitFailed($"Unable to load {ScriptName}. {CompilerErrors}");`
	`43`	`+ InitFailed($"Unable to load {ScriptName}. {CompilerErrors.JoinValues(Environment.NewLine)}");`
`44`	`44`	`return;`
`45`	`45`	`}`
`46`	`46`
`@@ -148,7 +148,7 @@ protected override void InitFailed(string message = null)`
`148`	`148`	`}`
`149`	`149`	`Interface.Oxide.LogInfo("Rolling back plugin to last good version: {0}", ScriptName);`
`150`	`150`	`CompiledAssembly = LastGoodAssembly;`
`151`		`- CompilerErrors = null;`
	`151`	`+ CompilerErrors.Clear();`
`152`	`152`	`LoadPlugin();`
`153`	`153`	`}`
`154`	`154`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ internal Compilation(int id, Action<Compilation> callback, CompilablePlugin[] pl`
`45`	`45`
`46`	`46`	`foreach (CompilablePlugin plugin in plugins)`
`47`	`47`	`{`
`48`		`- plugin.CompilerErrors = null;`
	`48`	`+ plugin.CompilerErrors.Clear();`
`49`	`49`	`plugin.OnCompilationStarted();`
`50`	`50`	`}`
`51`	`51`
`@@ -77,7 +77,7 @@ internal void Add(CompilablePlugin plugin)`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`plugin.Loader.PluginLoadingStarted(plugin);`
`80`		`- plugin.CompilerErrors = null;`
	`80`	`+ plugin.CompilerErrors.Clear();`
`81`	`81`	`plugin.OnCompilationStarted();`
`82`	`82`
`83`	`83`	`foreach (Core.Plugins.Plugin pl in Interface.Oxide.RootPluginManager.GetPlugins().Where(pl => pl is CSharpPlugin))`
`@@ -100,7 +100,7 @@ internal bool IncludesRequiredPlugin(string name)`
`100`	`100`	`}`
`101`	`101`
`102`	`102`	`CompilablePlugin compilablePlugin = plugins.SingleOrDefault(pl => pl.Name == name);`
`103`		`- return compilablePlugin != null && compilablePlugin.CompilerErrors == null;`
	`103`	`+ return compilablePlugin is { CompilerErrors.Count: 0 };`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`internal void Prepare(Action callback)`
`@@ -221,7 +221,7 @@ private void PreparseScript(CompilablePlugin plugin)`
`221`	`221`	`if (line.IndexOf("namespace uMod.Plugins", StringComparison.InvariantCultureIgnoreCase) >= 0)`
`222`	`222`	`{`
`223`	`223`	`Interface.Oxide.LogError($"Plugin {plugin.ScriptName}.cs is a uMod plugin, not an Oxide plugin. Please downgrade to the Oxide version if available.");`
`224`		`- plugin.CompilerErrors = $"Plugin {plugin.ScriptName}.cs is a uMod plugin, not an Oxide plugin. Please downgrade to the Oxide version if available.";`
	`224`	`+ plugin.CompilerErrors.Add($"Plugin {plugin.ScriptName}.cs is a uMod plugin, not an Oxide plugin. Please downgrade to the Oxide version if available.");`
`225`	`225`	`RemovePlugin(plugin);`
`226`	`226`	`return;`
`227`	`227`	`}`
`@@ -259,7 +259,7 @@ private void PreparseScript(CompilablePlugin plugin)`
`259`	`259`	`if (className != plugin.Name)`
`260`	`260`	`{`
`261`	`261`	`Interface.Oxide.LogError($"Plugin filename {plugin.ScriptName}.cs must match the main class {className} (should be {className}.cs)");`
`262`		`- plugin.CompilerErrors = $"Plugin filename {plugin.ScriptName}.cs must match the main class {className} (should be {className}.cs)";`
	`262`	`+ plugin.CompilerErrors.Add($"Plugin filename {plugin.ScriptName}.cs must match the main class {className} (should be {className}.cs)");`
`263`	`263`	`RemovePlugin(plugin);`
`264`	`264`	`}`
`265`	`265`
`@@ -275,7 +275,7 @@ private void PreparseScript(CompilablePlugin plugin)`
`275`	`275`	`if (!File.Exists(Path.Combine(plugin.Directory, dependencyName + ".cs")))`
`276`	`276`	`{`
`277`	`277`	`Interface.Oxide.LogError($"{plugin.Name} plugin requires missing dependency: {dependencyName}");`
`278`		`- plugin.CompilerErrors = $"Missing dependency: {dependencyName}";`
	`278`	`+ plugin.CompilerErrors.Add($"Missing dependency: {dependencyName}");`
`279`	`279`	`RemovePlugin(plugin);`
`280`	`280`	`return;`
`281`	`281`	`}`
`@@ -360,7 +360,7 @@ private void ResolveReferences(CompilablePlugin plugin)`
`360`	`360`
`361`	`361`	`string message = $"{fullName} is referenced by {plugin.Name} plugin but is not loaded";`
`362`	`362`	`Interface.Oxide.LogError(message);`
`363`		`- plugin.CompilerErrors = message;`
	`363`	`+ plugin.CompilerErrors.Add(message);`
`364`	`364`	`RemovePlugin(plugin);`
`365`	`365`	`}`
`366`	`366`	`}`
`@@ -401,7 +401,7 @@ private void AddReference(CompilablePlugin plugin, string assemblyNameString)`
`401`	`401`	`}`
`402`	`402`
`403`	`403`	`Interface.Oxide.LogError($"Assembly referenced by {plugin.Name} plugin does not exist: {assemblyNameString}.dll");`
`404`		`- plugin.CompilerErrors = $"Referenced assembly does not exist: {assemblyNameString}";`
	`404`	`+ plugin.CompilerErrors.Add($"Referenced assembly does not exist: {assemblyNameString}");`
`405`	`405`	`RemovePlugin(plugin);`
`406`	`406`	`return;`
`407`	`407`	`}`
`@@ -414,7 +414,7 @@ private void AddReference(CompilablePlugin plugin, string assemblyNameString)`
`414`	`414`	`catch (FileNotFoundException)`
`415`	`415`	`{`
`416`	`416`	`Interface.Oxide.LogError($"Assembly referenced by {plugin.Name} plugin is invalid: {assemblyNameString}.dll");`
`417`		`- plugin.CompilerErrors = $"Referenced assembly is invalid: {assemblyNameString}";`
	`417`	`+ plugin.CompilerErrors.Add($"Referenced assembly is invalid: {assemblyNameString}");`
`418`	`418`	`RemovePlugin(plugin);`
`419`	`419`	`return;`
`420`	`420`	`}`
`@@ -466,7 +466,7 @@ private bool CacheScriptLines(CompilablePlugin plugin)`
`466`	`466`	`if (!File.Exists(plugin.ScriptPath))`
`467`	`467`	`{`
`468`	`468`	`Interface.Oxide.LogWarning("Script no longer exists: {0}", plugin.Name);`
`469`		`- plugin.CompilerErrors = "Plugin file was deleted";`
	`469`	`+ plugin.CompilerErrors.Add("Plugin file was deleted");`
`470`	`470`	`RemovePlugin(plugin);`
`471`	`471`	`return false;`
`472`	`472`	`}`
Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,7 @@ private void ValidateAssembly(Action<byte[], byte[]> callback)`
`124`	`124`	`AssemblyDefinition assemblyDefinition = AssemblyDefinition.ReadAssembly(assemblyStream, readerParameters);`
`125`	`125`
`126`	`126`	`int foundPlugins = 0;`
`127`		`- int totalPlugins = CompilablePlugins.Count(p => p.CompilerErrors == null);`
	`127`	`+ int totalPlugins = CompilablePlugins.Count(p => p.CompilerErrors.Count == 0);`
`128`	`128`	`for (int i = 0; i < assemblyDefinition.MainModule.Types.Count; i++)`
`129`	`129`	`{`
`130`	`130`	`if (foundPlugins == totalPlugins)`
`@@ -159,10 +159,7 @@ private void ValidateAssembly(Action<byte[], byte[]> callback)`
`159`	`159`	`$"User defined constructors are not supported. Please remove the constructor from {typeDefinition.Name}.cs"); // Should be allowed`
`160`	`160`
`161`	`161`	`CompilablePlugin plugin = CompilablePlugins.SingleOrDefault(p => p.Name == typeDefinition.Name);`
`162`		`- if (plugin != null)`
`163`		`- {`
`164`		`- plugin.CompilerErrors = "Primary constructor in main class must be public";`
`165`		`- }`
	`162`	`+ plugin?.CompilerErrors.Add("Primary constructor in main class must be public");`
`166`	`163`	`}`
`167`	`164`	`else`
`168`	`165`	`{`
Original file line number	Diff line number	Diff line change
`@@ -326,14 +326,13 @@ private void OnMessageReceived(CompilerMessage message)`
`326`	`326`	`string[] missingRequirementsArray = missingRequirements.ToArray();`
`327`	`327`	`if (missingRequirementsArray.Length > 0)`
`328`	`328`	`{`
`329`		`- compilablePlugin.CompilerErrors = $"Missing dependencies: {string.Join(",", missingRequirementsArray)}";`
	`329`	`+ compilablePlugin.CompilerErrors.Add($"Missing dependencies: {string.Join(",", missingRequirementsArray)}");`
`330`	`330`
`331`	`331`	`Log(LogType.Error, $"[{error.File}] Missing dependencies: {string.Join(",", missingRequirementsArray)}");`
`332`	`332`	`}`
`333`	`333`	`else`
`334`	`334`	`{`
`335`		`- // TODO: Allow multiple errors`
`336`		`- compilablePlugin.CompilerErrors = error.Message;`
	`335`	`+ compilablePlugin.CompilerErrors.Add(error.Message);`
`337`	`336`
`338`	`337`	`Log(LogType.Error, $"[{error.File}] {error.Message}");`
`339`	`338`	`}`
`@@ -370,7 +369,7 @@ private void OnMessageReceived(CompilerMessage message)`
`370`	`369`
`371`	`370`	`foreach (CompilablePlugin p in compilation.plugins)`
`372`	`371`	`{`
`373`		`- p.CompilerErrors = errorMessage;`
	`372`	`+ p.CompilerErrors.Add(errorMessage);`
`374`	`373`	`}`
`375`	`374`
`376`	`375`	`compilation.Completed();`
`@@ -558,7 +557,7 @@ private void EnqueueCompilation(Compilation compilation)`
`558`	`557`	`string name = Path.GetFileName(plugin.ScriptPath ?? plugin.ScriptName);`
`559`	`558`	`if (plugin.ScriptSource == null \|\| plugin.ScriptSource.Length == 0)`
`560`	`559`	`{`
`561`		`- plugin.CompilerErrors = "No data contained in .cs file";`
	`560`	`+ plugin.CompilerErrors.Add("No data contained in .cs file");`
`562`	`561`	`Log(LogType.Error, $"Ignoring plugin {name}, file is empty");`
`563`	`562`	`continue;`
`564`	`563`	`}`
`@@ -629,7 +628,7 @@ private void OnCompilerFailed(string reason)`
`629`	`628`	`{`
`630`	`629`	`foreach (CompilablePlugin plugin in compilation.plugins)`
`631`	`630`	`{`
`632`		`- plugin.CompilerErrors = reason;`
	`631`	`+ plugin.CompilerErrors.Add(reason);`
`633`	`632`	`}`
`634`	`633`
`635`	`634`	`compilation.Completed();`