Standardise code formatting across entire repo

Author: SamboyCoding

Cpp2IL.Core.Tests/AccessibilityExtensionsTests.cs

@@ -13,10 +13,10 @@ public void AccessibilityTests()
         var mscorlib = appContext.AssembliesByName["mscorlib"];
         var coreModule = appContext.AssembliesByName["UnityEngine.CoreModule"];
 
-        var console = GetTypeByFullName(mscorlib, "System.Console");//public
-        var consoleWindowsConsole = GetTypeByFullName(mscorlib, "System.Console.WindowsConsole");//private nested
-        var dateTimeFormat = GetTypeByFullName(mscorlib, "System.DateTimeFormat");//internal
-        var gameObject = GetTypeByFullName(coreModule, "UnityEngine.GameObject");//public
+        var console = GetTypeByFullName(mscorlib, "System.Console"); //public
+        var consoleWindowsConsole = GetTypeByFullName(mscorlib, "System.Console.WindowsConsole"); //private nested
+        var dateTimeFormat = GetTypeByFullName(mscorlib, "System.DateTimeFormat"); //internal
+        var gameObject = GetTypeByFullName(coreModule, "UnityEngine.GameObject"); //public
         Assert.Multiple(() =>
         {
             AssertAccessibleTo(console, consoleWindowsConsole);

Cpp2IL.Core.Tests/Cpp2IlApiTests.cs

@@ -1,6 +1,7 @@
 using NUnit.Framework;
 
 namespace Cpp2IL.Core.Tests;
+
 public class Cpp2IlApiTests
 {
     [Test]

Cpp2IL.Core.Tests/GraphingTests.cs

@@ -6,6 +6,7 @@ namespace Cpp2IL.Core.Tests;
 public class GraphingTests
 {
     ISILControlFlowGraph graph;
+
     [SetUp]
     public void Setup()
     {

Cpp2IL.Core.Tests/Paths.cs

@@ -1,4 +1,5 @@
 namespace Cpp2IL.Core.Tests;
+
 public static class Paths
 {
     public const string TestProjectDirectory = "../../../";

Cpp2IL.Core/Api/Cpp2IlInstructionSet.cs

@@ -39,11 +39,11 @@ public abstract class Cpp2IlInstructionSet
     /// </summary>
     /// <returns>A subclass of <see cref="BaseKeyFunctionAddresses"/> specific to this instruction set</returns>
     public abstract BaseKeyFunctionAddresses CreateKeyFunctionAddressesInstance();
-    
+
     /// <summary>
     /// Create a string containing the raw native disassembly of the given method. You should print one instruction per line, alongside its address if applicable and available. 
     /// </summary>
     /// <param name="context">The method context to disassemble.</param>
     /// <returns>A string containing one instruction per line.</returns>
     public abstract string PrintAssembly(MethodAnalysisContext context);
-}
+}

Cpp2IL.Core/Api/Cpp2IlOutputFormat.cs

@@ -8,7 +8,7 @@ public abstract class Cpp2IlOutputFormat
     /// The ID of the output format as used when specifying an output format (e.g. in the command line)
     /// </summary>
     public abstract string OutputFormatId { get; }
-    
+
     /// <summary>
     /// The name of the output format displayed to the user (e.g. in logs or the GUI)
     /// </summary>
@@ -20,8 +20,7 @@ public abstract class Cpp2IlOutputFormat
     /// </summary>
     public virtual void OnOutputFormatSelected()
     {
-        
     }
-    
+
     public abstract void DoOutput(ApplicationAnalysisContext context, string outputRoot);
-}
+}

Cpp2IL.Core/Api/Cpp2IlPlugin.cs

@@ -9,7 +9,7 @@ namespace Cpp2IL.Core.Api;
 public abstract class Cpp2IlPlugin
 {
     protected readonly PluginLogger Logger;
-    
+
     private readonly List<string> temporaryFilePaths = [];
 
     protected Cpp2IlPlugin()
@@ -24,16 +24,16 @@ public string GetTemporaryFilePath()
         temporaryFilePaths.Add(ret);
         return ret;
     }
-    
+
     public abstract string Name { get; }
     public abstract string Description { get; }
-    
+
     public abstract void OnLoad();
 
-    protected void RegisterBinaryFormat<T>(string name, Func<byte[], bool> isValid, Func<MemoryStream, T> factory) where T : Il2CppBinary => 
+    protected void RegisterBinaryFormat<T>(string name, Func<byte[], bool> isValid, Func<MemoryStream, T> factory) where T : Il2CppBinary =>
         LibCpp2IlBinaryRegistry.Register(name, Name, isValid, factory);
-    
-    protected void RegisterBinaryRegistrationFuncFallbackHandler(Il2CppBinary.RegistrationStructLocationFailureHandler handler) => 
+
+    protected void RegisterBinaryRegistrationFuncFallbackHandler(Il2CppBinary.RegistrationStructLocationFailureHandler handler) =>
         Il2CppBinary.OnRegistrationStructLocationFailure += handler;
 
     /// <summary>
@@ -51,6 +51,7 @@ internal void CallOnFinish()
         {
             File.Delete(file);
         }
+
         OnFinish();
     }
 
@@ -59,6 +60,5 @@ internal void CallOnFinish()
     /// </summary>
     protected virtual void OnFinish()
     {
-        
     }
 }

Cpp2IL.Core/Api/Cpp2IlProcessingLayer.cs

@@ -23,7 +23,6 @@ public abstract class Cpp2IlProcessingLayer
     /// <param name="layers">A list of all layers that will run, which you can modify freely. Only layers left in this list once all layers return from PreProcess will have Process called.</param>
     public virtual void PreProcess(ApplicationAnalysisContext context, List<Cpp2IlProcessingLayer> layers)
     {
-        
     }
 
     /// <summary>
@@ -35,4 +34,4 @@ public virtual void PreProcess(ApplicationAnalysisContext context, List<Cpp2IlPr
     /// How you define steps is up to you - this is only used for providing user feedback.
     /// </param>
     public abstract void Process(ApplicationAnalysisContext appContext, Action<int, int>? progressCallback = null);
-}
+}

Cpp2IL.Core/Api/InstructionSetRegistry.cs

@@ -8,6 +8,6 @@ public static class InstructionSetRegistry
     private static Dictionary<InstructionSetId, Cpp2IlInstructionSet> _registeredSets = new();
 
     public static void RegisterInstructionSet<T>(InstructionSetId forId) where T : Cpp2IlInstructionSet, new() => _registeredSets.Add(forId, new T());
-    
+
     public static Cpp2IlInstructionSet GetInstructionSet(InstructionSetId forId) => _registeredSets[forId];
-}
+}

Cpp2IL.Core/Api/OutputFormatRegistry.cs

@@ -7,15 +7,15 @@ namespace Cpp2IL.Core.Api;
 public static class OutputFormatRegistry
 {
     private static readonly Dictionary<string, Cpp2IlOutputFormat> _formatsById = new();
-    
+
     public static IReadOnlyList<Cpp2IlOutputFormat> AllOutputFormats => _formatsById.Values.ToList();
 
     public static void Register<T>() where T : Cpp2IlOutputFormat, new()
     {
         var format = new T();
         _formatsById.Add(format.OutputFormatId, format);
     }
-    
-    public static Cpp2IlOutputFormat GetFormat(string formatId) 
+
+    public static Cpp2IlOutputFormat GetFormat(string formatId)
         => _formatsById.TryGetValue(formatId, out var format) ? format : throw new ArgumentException($"No output format registered with id '{formatId}'");
-}
+}

Cpp2IL.Core/Api/PluginLogger.cs

@@ -12,20 +12,20 @@ internal PluginLogger(Cpp2IlPlugin plugin)
         _plugin = plugin;
         _name = $"Plugin: {plugin.Name}";
     }
-        
+
     public void VerboseNewline(string message, string source = "Program") => Logger.VerboseNewline($"{message}", _name);
 
     public void Verbose(string message, string source = "Program") => Logger.Verbose($"{message}", _name);
-        
+
     public void InfoNewline(string message, string source = "Program") => Logger.InfoNewline($"{message}", _name);
 
     public void Info(string message, string source = "Program") => Logger.Info($"{message}", _name);
-        
+
     public void WarnNewline(string message, string source = "Program") => Logger.WarnNewline($"{message}", _name);
 
     public void Warn(string message, string source = "Program") => Logger.Warn($"{message}", _name);
-        
+
     public void ErrorNewline(string message, string source = "Program") => Logger.ErrorNewline($"{message}", _name);
 
     public void Error(string message, string source = "Program") => Logger.Error($"{message}", _name);
-}
+}

Cpp2IL.Core/Api/ProcessingLayerRegistry.cs

@@ -7,15 +7,15 @@ namespace Cpp2IL.Core.Api;
 public static class ProcessingLayerRegistry
 {
     private static readonly Dictionary<string, Cpp2IlProcessingLayer> _processingLayersById = new();
-    
+
     public static IReadOnlyList<Cpp2IlProcessingLayer> AllProcessingLayers => _processingLayersById.Values.ToList();
 
     public static void Register<T>() where T : Cpp2IlProcessingLayer, new()
     {
         var layer = new T();
         _processingLayersById.Add(layer.Id, layer);
     }
-    
-    public static Cpp2IlProcessingLayer GetById(string id) 
+
+    public static Cpp2IlProcessingLayer GetById(string id)
         => _processingLayersById.TryGetValue(id, out var ret) ? ret : throw new ArgumentException($"No processing layer with id {id} registered");
-}
+}

Cpp2IL.Core/Cpp2IlCorePlugin.cs

@@ -15,32 +15,32 @@ namespace Cpp2IL.Core;
 public class Cpp2IlCorePlugin : Cpp2IlPlugin
 {
     public override string Name => "Cpp2IL Built-In";
-    
+
     public override string Description => "Core Cpp2IL plugin containing built-in instruction sets, binaries, and other core functionality.";
-    
+
     public override void OnLoad()
     {
         Logger.VerboseNewline("Initializing...", "Core Plugin");
         var start = DateTime.Now;
-        
+
         Logger.VerboseNewline("\tRegistering built-in instruction set handlers...", "Core Plugin");
-        
+
         InstructionSetRegistry.RegisterInstructionSet<X86InstructionSet>(DefaultInstructionSets.X86_32);
         InstructionSetRegistry.RegisterInstructionSet<X86InstructionSet>(DefaultInstructionSets.X86_64);
         InstructionSetRegistry.RegisterInstructionSet<WasmInstructionSet>(DefaultInstructionSets.WASM);
         InstructionSetRegistry.RegisterInstructionSet<ArmV7InstructionSet>(DefaultInstructionSets.ARM_V7);
-        
-        if(Environment.GetEnvironmentVariable("CPP2IL_LEGACY_ARM64") != null)
+
+        if (Environment.GetEnvironmentVariable("CPP2IL_LEGACY_ARM64") != null)
             InstructionSetRegistry.RegisterInstructionSet<Arm64InstructionSet>(DefaultInstructionSets.ARM_V8);
         else
             InstructionSetRegistry.RegisterInstructionSet<NewArmV8InstructionSet>(DefaultInstructionSets.ARM_V8);
-        
+
         Logger.VerboseNewline("\tRegistering built-in binary parsers...", "Core Plugin");
-        
+
         LibCpp2IlBinaryRegistry.RegisterBuiltInBinarySupport();
-        
+
         Logger.VerboseNewline("\tRegistering built-in output formats...", "Core Plugin");
-        
+
         OutputFormatRegistry.Register<AsmResolverDllOutputFormatLegacy>();
         OutputFormatRegistry.Register<AsmResolverDllOutputFormatDefault>();
         OutputFormatRegistry.Register<AsmResolverDllOutputFormatEmpty>();
@@ -49,9 +49,9 @@ public override void OnLoad()
         OutputFormatRegistry.Register<DiffableCsOutputFormat>();
         OutputFormatRegistry.Register<IsilDumpOutputFormat>();
         OutputFormatRegistry.Register<WasmMappingOutputFormat>();
-        
+
         Logger.VerboseNewline("\tRegistering built-in processing layers", "Core Plugin");
-        
+
         ProcessingLayerRegistry.Register<AttributeAnalysisProcessingLayer>();
         ProcessingLayerRegistry.Register<AttributeInjectorProcessingLayer>();
         ProcessingLayerRegistry.Register<CallAnalysisProcessingLayer>();

Cpp2IL.Core/Cpp2IlPluginManager.cs

@@ -18,10 +18,10 @@ public static class Cpp2IlPluginManager
     internal static void LoadFromDirectory(string pluginsDir)
     {
         Logger.InfoNewline($"Loading plugins from {pluginsDir}...", "Plugins");
-        
-        if(!Directory.Exists(pluginsDir))
+
+        if (!Directory.Exists(pluginsDir))
             return;
-        
+
         foreach (var file in Directory.EnumerateFiles(pluginsDir))
         {
             if (Path.GetExtension(file) == ".dll")
@@ -31,37 +31,37 @@ internal static void LoadFromDirectory(string pluginsDir)
             }
         }
     }
-    
+
     internal static void InitAll()
     {
         var assemblies = AppDomain.CurrentDomain.GetAssemblies();
         Logger.VerboseNewline("Collecting and instantiating plugins...", "Plugins");
-        
+
         foreach (var assembly in assemblies)
         {
             var attrs = assembly.GetCustomAttributes<RegisterCpp2IlPluginAttribute>().ToList();
-                
-            if(attrs.Count == 0)
+
+            if (attrs.Count == 0)
                 continue;
-                
+
             foreach (var registerCpp2IlPluginAttribute in attrs)
             {
                 Cpp2IlPlugin plugin;
                 try
                 {
                     Logger.VerboseNewline($"\tLoading plugin {registerCpp2IlPluginAttribute.PluginType.FullName} from assembly: {assembly.GetName().Name}.dll", "Plugins");
-                    plugin = (Cpp2IlPlugin) Activator.CreateInstance(registerCpp2IlPluginAttribute.PluginType)!;
+                    plugin = (Cpp2IlPlugin)Activator.CreateInstance(registerCpp2IlPluginAttribute.PluginType)!;
                 }
                 catch (Exception e)
                 {
                     Logger.ErrorNewline($"Plugin {registerCpp2IlPluginAttribute.PluginType.FullName} from assembly {assembly.GetName().Name} threw an exception during construction: {e}. It will not be loaded.", "Plugins");
                     continue;
                 }
-                
+
                 _loadedPlugins.Add(plugin);
             }
         }
-        
+
         Logger.VerboseNewline("Invoking OnLoad on " + _loadedPlugins.Count + " plugins.", "Plugins");
         foreach (var plugin in _loadedPlugins)
         {
@@ -76,6 +76,7 @@ internal static void InitAll()
                 _loadedPlugins.Remove(plugin);
             }
         }
+
         Logger.VerboseNewline("OnLoad complete", "Plugins");
     }
 

Cpp2IL.Core/Cpp2IlRuntimeArgs.cs

@@ -8,7 +8,7 @@ public class Cpp2IlRuntimeArgs
 {
     //To determine easily if this struct is the default one or not.
     public bool Valid;
-        
+
     //Core variables
     public UnityVersion UnityVersion;
     public string PathToAssembly = null!;
@@ -18,9 +18,9 @@ public class Cpp2IlRuntimeArgs
 
     public List<Cpp2IlProcessingLayer> ProcessingLayersToRun = [];
     public readonly Dictionary<string, string> ProcessingLayerConfigurationOptions = new();
-        
+
     public Cpp2IlOutputFormat? OutputFormat;
     public string OutputRootDirectory = null!;
-        
+
     public bool LowMemoryMode;
-}
+}

Cpp2IL.Core/Exceptions/DllSaveException.cs

@@ -7,4 +7,4 @@ public class DllSaveException(string fullPath, Exception cause)
 {
     public string FullPath { get; } = fullPath;
     public Exception Cause { get; } = cause;
-}
+}

Cpp2IL.Core/Exceptions/InstructionSetHandlerNotRegisteredException.cs

@@ -4,4 +4,4 @@
 namespace Cpp2IL.Core.Exceptions;
 
 public class InstructionSetHandlerNotRegisteredException(InstructionSetId instructionSetId) : Exception(
-    $"Instruction set handler not registered for instruction set {instructionSetId.Name}. Please register an instruction set handler using InstructionSetRegistry.RegisterInstructionSet<T>(id)");
+    $"Instruction set handler not registered for instruction set {instructionSetId.Name}. Please register an instruction set handler using InstructionSetRegistry.RegisterInstructionSet<T>(id)");

Cpp2IL.Core/Exceptions/LibCpp2ILInitializationException.cs

@@ -3,4 +3,4 @@
 namespace Cpp2IL.Core.Exceptions;
 
 public class LibCpp2ILInitializationException(string message, Exception innerException)
-    : Exception(message, innerException);
+    : Exception(message, innerException);

Cpp2IL.Core/Exceptions/LibraryNotInitializedException.cs

@@ -5,4 +5,4 @@ namespace Cpp2IL.Core.Exceptions;
 public class LibraryNotInitializedException : Exception
 {
     public override string Message => "This function requires LibCpp2IL to be initialized - there is a function to do this in Cpp2IlApi.";
-}
+}

Cpp2IL.Core/Exceptions/NodeConditionCalculationException.cs

@@ -2,4 +2,4 @@
 
 namespace Cpp2IL.Core.Exceptions;
 
-public class NodeConditionCalculationException(string message) : Exception(message);
+public class NodeConditionCalculationException(string message) : Exception(message);