[ARMeilleure] Address dotnet-format issues (#5357)

* dotnet format style --severity info

Some changes were manually reverted.

* dotnet format analyzers --serverity info

Some changes have been minimally adapted.

* Restore a few unused methods and variables

* Silence dotnet format IDE0060 warnings

* Silence dotnet format IDE0052 warnings

* Address or silence dotnet format IDE1006 warnings

* Address or silence dotnet format CA2208 warnings

* Address dotnet format CA1822 warnings

* Address or silence dotnet format CA1069 warnings

* Silence CA1806 and CA1834 issues

* Address dotnet format CA1401 warnings

* Fix new dotnet-format issues after rebase

* Address review comments

* Address dotnet format CA2208 warnings properly

* Fix formatting for switch expressions

* Address most dotnet format whitespace warnings

* Apply dotnet format whitespace formatting

A few of them have been manually reverted and the corresponding warning was silenced

* Add previously silenced warnings back

I have no clue how these disappeared

* Revert formatting changes for OpCodeTable.cs

* Enable formatting for a few cases again

* Format if-blocks correctly

* Enable formatting for a few more cases again

* Fix inline comment alignment

* Run dotnet format after rebase and remove unused usings

- analyzers
- style
- whitespace

* Disable 'prefer switch expression' rule

* Add comments to disabled warnings

* Remove a few unused parameters

* Adjust namespaces

* Simplify properties and array initialization, Use const when possible, Remove trailing commas

* Start working on disabled warnings

* Fix and silence a few dotnet-format warnings again

* Address IDE0251 warnings

* Address a few disabled IDE0060 warnings

* Silence IDE0060 in .editorconfig

* Revert "Simplify properties and array initialization, Use const when possible, Remove trailing commas"

This reverts commit 9462e4136c0a2100dc28b20cf9542e06790aa67e.

* dotnet format whitespace after rebase

* First dotnet format pass

* Remove unnecessary formatting exclusion

* Add unsafe dotnet format changes

* Change visibility of JitSupportDarwin to internal

7 files changed, 227 insertions, 226 deletions

diff --git a/src/ARMeilleure/Translation/PTC/EncodingCache.cs b/src/ARMeilleure/Translation/PTC/EncodingCache.cs
index 90d40c47..d9b38ace 100644
--- a/src/ARMeilleure/Translation/PTC/EncodingCache.cs
+++ b/src/ARMeilleure/Translation/PTC/EncodingCache.cs
@@ -6,4 +6,4 @@ namespace ARMeilleure.Translation.PTC
     {
         public static readonly Encoding UTF8NoBOM = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);
     }
-}
\ No newline at end of file
+}
diff --git a/src/ARMeilleure/Translation/PTC/IPtcLoadState.cs b/src/ARMeilleure/Translation/PTC/IPtcLoadState.cs
index 1b11ac0b..efff45a9 100644
--- a/src/ARMeilleure/Translation/PTC/IPtcLoadState.cs
+++ b/src/ARMeilleure/Translation/PTC/IPtcLoadState.cs
@@ -7,4 +7,4 @@ namespace ARMeilleure.Translation.PTC
         event Action<PtcLoadingState, int, int> PtcStateChanged;
         void Continue();
     }
-}
\ No newline at end of file
+}
diff --git a/src/ARMeilleure/Translation/PTC/Ptc.cs b/src/ARMeilleure/Translation/PTC/Ptc.cs
index 3c697bff..665f568d 100644
--- a/src/ARMeilleure/Translation/PTC/Ptc.cs
+++ b/src/ARMeilleure/Translation/PTC/Ptc.cs
@@ -17,13 +17,12 @@ using System.Runtime;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Threading;
-
 using static ARMeilleure.Translation.PTC.PtcFormatter;
 
 namespace ARMeilleure.Translation.PTC
 {
-    using Arm64HardwareCapabilities = ARMeilleure.CodeGen.Arm64.HardwareCapabilities;
-    using X86HardwareCapabilities = ARMeilleure.CodeGen.X86.HardwareCapabilities;
+    using Arm64HardwareCapabilities = CodeGen.Arm64.HardwareCapabilities;
+    using X86HardwareCapabilities = CodeGen.X86.HardwareCapabilities;
 
     class Ptc : IPtcLoadState
     {
@@ -187,8 +186,8 @@ namespace ARMeilleure.Translation.PTC
             string fileNameActual = $"{CachePathActual}.cache";
             string fileNameBackup = $"{CachePathBackup}.cache";
 
-            FileInfo fileInfoActual = new FileInfo(fileNameActual);
-            FileInfo fileInfoBackup = new FileInfo(fileNameBackup);
+            FileInfo fileInfoActual = new(fileNameActual);
+            FileInfo fileInfoBackup = new(fileNameBackup);
 
             if (fileInfoActual.Exists && fileInfoActual.Length != 0L)
             {
@@ -275,104 +274,102 @@ namespace ARMeilleure.Translation.PTC
                 {
                     intPtr = Marshal.AllocHGlobal(new IntPtr(outerHeader.UncompressedStreamSize));
 
-                    using (UnmanagedMemoryStream stream = new((byte*)intPtr.ToPointer(), outerHeader.UncompressedStreamSize, outerHeader.UncompressedStreamSize, FileAccess.ReadWrite))
+                    using UnmanagedMemoryStream stream = new((byte*)intPtr.ToPointer(), outerHeader.UncompressedStreamSize, outerHeader.UncompressedStreamSize, FileAccess.ReadWrite);
+                    try
                     {
-                        try
-                        {
-                            deflateStream.CopyTo(stream);
-                        }
-                        catch
-                        {
-                            InvalidateCompressedStream(compressedStream);
+                        deflateStream.CopyTo(stream);
+                    }
+                    catch
+                    {
+                        InvalidateCompressedStream(compressedStream);
 
-                            return false;
-                        }
+                        return false;
+                    }
 
-                        Debug.Assert(stream.Position == stream.Length);
+                    Debug.Assert(stream.Position == stream.Length);
 
-                        stream.Seek(0L, SeekOrigin.Begin);
+                    stream.Seek(0L, SeekOrigin.Begin);
 
-                        InnerHeader innerHeader = DeserializeStructure<InnerHeader>(stream);
+                    InnerHeader innerHeader = DeserializeStructure<InnerHeader>(stream);
 
-                        if (!innerHeader.IsHeaderValid())
-                        {
-                            InvalidateCompressedStream(compressedStream);
+                    if (!innerHeader.IsHeaderValid())
+                    {
+                        InvalidateCompressedStream(compressedStream);
 
-                            return false;
-                        }
+                        return false;
+                    }
 
-                        if (innerHeader.Magic != _innerHeaderMagic)
-                        {
-                            InvalidateCompressedStream(compressedStream);
+                    if (innerHeader.Magic != _innerHeaderMagic)
+                    {
+                        InvalidateCompressedStream(compressedStream);
 
-                            return false;
-                        }
+                        return false;
+                    }
 
-                        ReadOnlySpan<byte> infosBytes = new(stream.PositionPointer, innerHeader.InfosLength);
-                        stream.Seek(innerHeader.InfosLength, SeekOrigin.Current);
+                    ReadOnlySpan<byte> infosBytes = new(stream.PositionPointer, innerHeader.InfosLength);
+                    stream.Seek(innerHeader.InfosLength, SeekOrigin.Current);
 
-                        Hash128 infosHash = XXHash128.ComputeHash(infosBytes);
+                    Hash128 infosHash = XXHash128.ComputeHash(infosBytes);
 
-                        if (innerHeader.InfosHash != infosHash)
-                        {
-                            InvalidateCompressedStream(compressedStream);
+                    if (innerHeader.InfosHash != infosHash)
+                    {
+                        InvalidateCompressedStream(compressedStream);
 
-                            return false;
-                        }
+                        return false;
+                    }
 
-                        ReadOnlySpan<byte> codesBytes = (int)innerHeader.CodesLength > 0 ? new(stream.PositionPointer, (int)innerHeader.CodesLength) : ReadOnlySpan<byte>.Empty;
-                        stream.Seek(innerHeader.CodesLength, SeekOrigin.Current);
+                    ReadOnlySpan<byte> codesBytes = (int)innerHeader.CodesLength > 0 ? new(stream.PositionPointer, (int)innerHeader.CodesLength) : ReadOnlySpan<byte>.Empty;
+                    stream.Seek(innerHeader.CodesLength, SeekOrigin.Current);
 
-                        Hash128 codesHash = XXHash128.ComputeHash(codesBytes);
+                    Hash128 codesHash = XXHash128.ComputeHash(codesBytes);
 
-                        if (innerHeader.CodesHash != codesHash)
-                        {
-                            InvalidateCompressedStream(compressedStream);
+                    if (innerHeader.CodesHash != codesHash)
+                    {
+                        InvalidateCompressedStream(compressedStream);
 
-                            return false;
-                        }
+                        return false;
+                    }
 
-                        ReadOnlySpan<byte> relocsBytes = new(stream.PositionPointer, innerHeader.RelocsLength);
-                        stream.Seek(innerHeader.RelocsLength, SeekOrigin.Current);
+                    ReadOnlySpan<byte> relocsBytes = new(stream.PositionPointer, innerHeader.RelocsLength);
+                    stream.Seek(innerHeader.RelocsLength, SeekOrigin.Current);
 
-                        Hash128 relocsHash = XXHash128.ComputeHash(relocsBytes);
+                    Hash128 relocsHash = XXHash128.ComputeHash(relocsBytes);
 
-                        if (innerHeader.RelocsHash != relocsHash)
-                        {
-                            InvalidateCompressedStream(compressedStream);
+                    if (innerHeader.RelocsHash != relocsHash)
+                    {
+                        InvalidateCompressedStream(compressedStream);
 
-                            return false;
-                        }
+                        return false;
+                    }
 
-                        ReadOnlySpan<byte> unwindInfosBytes = new(stream.PositionPointer, innerHeader.UnwindInfosLength);
-                        stream.Seek(innerHeader.UnwindInfosLength, SeekOrigin.Current);
+                    ReadOnlySpan<byte> unwindInfosBytes = new(stream.PositionPointer, innerHeader.UnwindInfosLength);
+                    stream.Seek(innerHeader.UnwindInfosLength, SeekOrigin.Current);
 
-                        Hash128 unwindInfosHash = XXHash128.ComputeHash(unwindInfosBytes);
+                    Hash128 unwindInfosHash = XXHash128.ComputeHash(unwindInfosBytes);
 
-                        if (innerHeader.UnwindInfosHash != unwindInfosHash)
-                        {
-                            InvalidateCompressedStream(compressedStream);
+                    if (innerHeader.UnwindInfosHash != unwindInfosHash)
+                    {
+                        InvalidateCompressedStream(compressedStream);
 
-                            return false;
-                        }
+                        return false;
+                    }
 
-                        Debug.Assert(stream.Position == stream.Length);
+                    Debug.Assert(stream.Position == stream.Length);
 
-                        stream.Seek((long)Unsafe.SizeOf<InnerHeader>(), SeekOrigin.Begin);
+                    stream.Seek((long)Unsafe.SizeOf<InnerHeader>(), SeekOrigin.Begin);
 
-                        _infosStream.Write(infosBytes);
-                        stream.Seek(innerHeader.InfosLength, SeekOrigin.Current);
+                    _infosStream.Write(infosBytes);
+                    stream.Seek(innerHeader.InfosLength, SeekOrigin.Current);
 
-                        _codesList.ReadFrom(stream);
+                    _codesList.ReadFrom(stream);
 
-                        _relocsStream.Write(relocsBytes);
-                        stream.Seek(innerHeader.RelocsLength, SeekOrigin.Current);
+                    _relocsStream.Write(relocsBytes);
+                    stream.Seek(innerHeader.RelocsLength, SeekOrigin.Current);
 
-                        _unwindInfosStream.Write(unwindInfosBytes);
-                        stream.Seek(innerHeader.UnwindInfosLength, SeekOrigin.Current);
+                    _unwindInfosStream.Write(unwindInfosBytes);
+                    stream.Seek(innerHeader.UnwindInfosLength, SeekOrigin.Current);
 
-                        Debug.Assert(stream.Position == stream.Length);
-                    }
+                    Debug.Assert(stream.Position == stream.Length);
                 }
                 finally
                 {
@@ -390,7 +387,7 @@ namespace ARMeilleure.Translation.PTC
             return true;
         }
 
-        private void InvalidateCompressedStream(FileStream compressedStream)
+        private static void InvalidateCompressedStream(FileStream compressedStream)
         {
             compressedStream.SetLength(0L);
         }
@@ -404,7 +401,7 @@ namespace ARMeilleure.Translation.PTC
                 string fileNameActual = $"{CachePathActual}.cache";
                 string fileNameBackup = $"{CachePathBackup}.cache";
 
-                FileInfo fileInfoActual = new FileInfo(fileNameActual);
+                FileInfo fileInfoActual = new(fileNameActual);
 
                 if (fileInfoActual.Exists && fileInfoActual.Length != 0L)
                 {
@@ -427,32 +424,34 @@ namespace ARMeilleure.Translation.PTC
         {
             int translatedFuncsCount;
 
-            InnerHeader innerHeader = new InnerHeader();
-
-            innerHeader.Magic = _innerHeaderMagic;
-
-            innerHeader.InfosLength = (int)_infosStream.Length;
-            innerHeader.CodesLength = _codesList.Length();
-            innerHeader.RelocsLength = (int)_relocsStream.Length;
-            innerHeader.UnwindInfosLength = (int)_unwindInfosStream.Length;
+            InnerHeader innerHeader = new()
+            {
+                Magic = _innerHeaderMagic,
 
-            OuterHeader outerHeader = new OuterHeader();
+                InfosLength = (int)_infosStream.Length,
+                CodesLength = _codesList.Length(),
+                RelocsLength = (int)_relocsStream.Length,
+                UnwindInfosLength = (int)_unwindInfosStream.Length,
+            };
 
-            outerHeader.Magic = _outerHeaderMagic;
+            OuterHeader outerHeader = new()
+            {
+                Magic = _outerHeaderMagic,
 
-            outerHeader.CacheFileVersion = InternalVersion;
-            outerHeader.Endianness = GetEndianness();
-            outerHeader.FeatureInfo = GetFeatureInfo();
-            outerHeader.MemoryManagerMode = GetMemoryManagerMode();
-            outerHeader.OSPlatform = GetOSPlatform();
-            outerHeader.Architecture = (uint)RuntimeInformation.ProcessArchitecture;
+                CacheFileVersion = InternalVersion,
+                Endianness = GetEndianness(),
+                FeatureInfo = GetFeatureInfo(),
+                MemoryManagerMode = GetMemoryManagerMode(),
+                OSPlatform = GetOSPlatform(),
+                Architecture = (uint)RuntimeInformation.ProcessArchitecture,
 
-            outerHeader.UncompressedStreamSize =
+                UncompressedStreamSize =
                 (long)Unsafe.SizeOf<InnerHeader>() +
                 innerHeader.InfosLength +
                 innerHeader.CodesLength +
                 innerHeader.RelocsLength +
-                innerHeader.UnwindInfosLength;
+                innerHeader.UnwindInfosLength,
+            };
 
             outerHeader.SetHeaderHash();
 
@@ -462,58 +461,54 @@ namespace ARMeilleure.Translation.PTC
             {
                 intPtr = Marshal.AllocHGlobal(new IntPtr(outerHeader.UncompressedStreamSize));
 
-                using (UnmanagedMemoryStream stream = new((byte*)intPtr.ToPointer(), outerHeader.UncompressedStreamSize, outerHeader.UncompressedStreamSize, FileAccess.ReadWrite))
-                {
-                    stream.Seek((long)Unsafe.SizeOf<InnerHeader>(), SeekOrigin.Begin);
+                using UnmanagedMemoryStream stream = new((byte*)intPtr.ToPointer(), outerHeader.UncompressedStreamSize, outerHeader.UncompressedStreamSize, FileAccess.ReadWrite);
+                stream.Seek((long)Unsafe.SizeOf<InnerHeader>(), SeekOrigin.Begin);
 
-                    ReadOnlySpan<byte> infosBytes = new(stream.PositionPointer, innerHeader.InfosLength);
-                    _infosStream.WriteTo(stream);
+                ReadOnlySpan<byte> infosBytes = new(stream.PositionPointer, innerHeader.InfosLength);
+                _infosStream.WriteTo(stream);
 
-                    ReadOnlySpan<byte> codesBytes = (int)innerHeader.CodesLength > 0 ? new(stream.PositionPointer, (int)innerHeader.CodesLength) : ReadOnlySpan<byte>.Empty;
-                    _codesList.WriteTo(stream);
+                ReadOnlySpan<byte> codesBytes = (int)innerHeader.CodesLength > 0 ? new(stream.PositionPointer, (int)innerHeader.CodesLength) : ReadOnlySpan<byte>.Empty;
+                _codesList.WriteTo(stream);
 
-                    ReadOnlySpan<byte> relocsBytes = new(stream.PositionPointer, innerHeader.RelocsLength);
-                    _relocsStream.WriteTo(stream);
+                ReadOnlySpan<byte> relocsBytes = new(stream.PositionPointer, innerHeader.RelocsLength);
+                _relocsStream.WriteTo(stream);
 
-                    ReadOnlySpan<byte> unwindInfosBytes = new(stream.PositionPointer, innerHeader.UnwindInfosLength);
-                    _unwindInfosStream.WriteTo(stream);
+                ReadOnlySpan<byte> unwindInfosBytes = new(stream.PositionPointer, innerHeader.UnwindInfosLength);
+                _unwindInfosStream.WriteTo(stream);
 
-                    Debug.Assert(stream.Position == stream.Length);
+                Debug.Assert(stream.Position == stream.Length);
 
-                    innerHeader.InfosHash = XXHash128.ComputeHash(infosBytes);
-                    innerHeader.CodesHash = XXHash128.ComputeHash(codesBytes);
-                    innerHeader.RelocsHash = XXHash128.ComputeHash(relocsBytes);
-                    innerHeader.UnwindInfosHash = XXHash128.ComputeHash(unwindInfosBytes);
+                innerHeader.InfosHash = XXHash128.ComputeHash(infosBytes);
+                innerHeader.CodesHash = XXHash128.ComputeHash(codesBytes);
+                innerHeader.RelocsHash = XXHash128.ComputeHash(relocsBytes);
+                innerHeader.UnwindInfosHash = XXHash128.ComputeHash(unwindInfosBytes);
 
-                    innerHeader.SetHeaderHash();
+                innerHeader.SetHeaderHash();
 
-                    stream.Seek(0L, SeekOrigin.Begin);
-                    SerializeStructure(stream, innerHeader);
+                stream.Seek(0L, SeekOrigin.Begin);
+                SerializeStructure(stream, innerHeader);
 
-                    translatedFuncsCount = GetEntriesCount();
+                translatedFuncsCount = GetEntriesCount();
 
-                    ResetCarriersIfNeeded();
+                ResetCarriersIfNeeded();
 
-                    using (FileStream compressedStream = new(fileName, FileMode.OpenOrCreate))
-                    using (DeflateStream deflateStream = new(compressedStream, SaveCompressionLevel, true))
-                    {
-                        try
-                        {
-                            SerializeStructure(compressedStream, outerHeader);
+                using FileStream compressedStream = new(fileName, FileMode.OpenOrCreate);
+                using DeflateStream deflateStream = new(compressedStream, SaveCompressionLevel, true);
+                try
+                {
+                    SerializeStructure(compressedStream, outerHeader);
 
-                            stream.Seek(0L, SeekOrigin.Begin);
-                            stream.CopyTo(deflateStream);
-                        }
-                        catch
-                        {
-                            compressedStream.Position = 0L;
-                        }
+                    stream.Seek(0L, SeekOrigin.Begin);
+                    stream.CopyTo(deflateStream);
+                }
+                catch
+                {
+                    compressedStream.Position = 0L;
+                }
 
-                        if (compressedStream.Position < compressedStream.Length)
-                        {
-                            compressedStream.SetLength(compressedStream.Position);
-                        }
-                    }
+                if (compressedStream.Position < compressedStream.Length)
+                {
+                    compressedStream.SetLength(compressedStream.Position);
                 }
             }
             finally
@@ -647,7 +642,7 @@ namespace ARMeilleure.Translation.PTC
             return _codesList[index];
         }
 
-        private RelocEntry[] GetRelocEntries(BinaryReader relocsReader, int relocEntriesCount)
+        private static RelocEntry[] GetRelocEntries(BinaryReader relocsReader, int relocEntriesCount)
         {
             RelocEntry[] relocEntries = new RelocEntry[relocEntriesCount];
 
@@ -663,7 +658,7 @@ namespace ARMeilleure.Translation.PTC
             return relocEntries;
         }
 
-        private void PatchCode(Translator translator, Span<byte> code, RelocEntry[] relocEntries, out Counter<uint> callCounter)
+        private static void PatchCode(Translator translator, Span<byte> code, RelocEntry[] relocEntries, out Counter<uint> callCounter)
         {
             callCounter = null;
 
@@ -678,7 +673,10 @@ namespace ARMeilleure.Translation.PTC
 
                     if (translator.FunctionTable.IsValid(guestAddress))
                     {
-                        unsafe { imm = (IntPtr)Unsafe.AsPointer(ref translator.FunctionTable.GetValue(guestAddress)); }
+                        unsafe
+                        {
+                            imm = (IntPtr)Unsafe.AsPointer(ref translator.FunctionTable.GetValue(guestAddress));
+                        }
                     }
                 }
                 else if (symbol.Type == SymbolType.DelegateTable)
@@ -696,12 +694,12 @@ namespace ARMeilleure.Translation.PTC
                 }
                 else if (symbol == CountTableSymbol)
                 {
-                    if (callCounter == null)
+                    callCounter ??= new Counter<uint>(translator.CountTable);
+
+                    unsafe
                     {
-                        callCounter = new Counter<uint>(translator.CountTable);
+                        imm = (IntPtr)Unsafe.AsPointer(ref callCounter.Value);
                     }
-
-                    unsafe { imm = (IntPtr)Unsafe.AsPointer(ref callCounter.Value); }
                 }
                 else if (symbol == DispatchStubSymbol)
                 {
@@ -717,7 +715,7 @@ namespace ARMeilleure.Translation.PTC
             }
         }
 
-        private UnwindInfo ReadUnwindInfo(BinaryReader unwindInfosReader)
+        private static UnwindInfo ReadUnwindInfo(BinaryReader unwindInfosReader)
         {
             int pushEntriesLength = unwindInfosReader.ReadInt32();
 
@@ -738,7 +736,7 @@ namespace ARMeilleure.Translation.PTC
             return new UnwindInfo(pushEntries, prologueSize);
         }
 
-        private TranslatedFunction FastTranslate(
+        private static TranslatedFunction FastTranslate(
             byte[] code,
             Counter<uint> callCounter,
             ulong guestSize,
@@ -809,13 +807,13 @@ namespace ARMeilleure.Translation.PTC
 
             PtcStateChanged?.Invoke(PtcLoadingState.Start, _translateCount, _translateTotalCount);
 
-            using AutoResetEvent progressReportEvent = new AutoResetEvent(false);
+            using AutoResetEvent progressReportEvent = new(false);
 
-            Thread progressReportThread = new Thread(ReportProgress)
+            Thread progressReportThread = new(ReportProgress)
             {
                 Name = "Ptc.ProgressReporter",
                 Priority = ThreadPriority.Lowest,
-                IsBackground = true
+                IsBackground = true,
             };
 
             progressReportThread.Start(progressReportEvent);
@@ -845,12 +843,14 @@ namespace ARMeilleure.Translation.PTC
                 }
             }
 
-            List<Thread> threads = new List<Thread>();
+            List<Thread> threads = new();
 
             for (int i = 0; i < degreeOfParallelism; i++)
             {
-                Thread thread = new Thread(TranslateFuncs);
-                thread.IsBackground = true;
+                Thread thread = new(TranslateFuncs)
+                {
+                    IsBackground = true,
+                };
 
                 threads.Add(thread);
             }
@@ -871,8 +871,10 @@ namespace ARMeilleure.Translation.PTC
 
             Logger.Info?.Print(LogClass.Ptc, $"{_translateCount} of {_translateTotalCount} functions translated | Thread count: {degreeOfParallelism} in {sw.Elapsed.TotalSeconds} s");
 
-            Thread preSaveThread = new Thread(PreSave);
-            preSaveThread.IsBackground = true;
+            Thread preSaveThread = new(PreSave)
+            {
+                IsBackground = true,
+            };
             preSaveThread.Start();
         }
 
@@ -910,15 +912,16 @@ namespace ARMeilleure.Translation.PTC
                 RelocInfo relocInfo = compiledFunc.RelocInfo;
                 UnwindInfo unwindInfo = compiledFunc.UnwindInfo;
 
-                InfoEntry infoEntry = new InfoEntry();
-
-                infoEntry.Address = address;
-                infoEntry.GuestSize = guestSize;
-                infoEntry.Hash = hash;
-                infoEntry.HighCq = highCq;
-                infoEntry.Stubbed = false;
-                infoEntry.CodeLength = code.Length;
-                infoEntry.RelocEntriesCount = relocInfo.Entries.Length;
+                InfoEntry infoEntry = new()
+                {
+                    Address = address,
+                    GuestSize = guestSize,
+                    Hash = hash,
+                    HighCq = highCq,
+                    Stubbed = false,
+                    CodeLength = code.Length,
+                    RelocEntriesCount = relocInfo.Entries.Length,
+                };
 
                 SerializeStructure(_infosStream, infoEntry);
 
@@ -996,10 +999,12 @@ namespace ARMeilleure.Translation.PTC
         {
             uint osPlatform = 0u;
 
+#pragma warning disable IDE0055 // Disable formatting
             osPlatform |= (OperatingSystem.IsFreeBSD() ? 1u : 0u) << 0;
             osPlatform |= (OperatingSystem.IsLinux()   ? 1u : 0u) << 1;
             osPlatform |= (OperatingSystem.IsMacOS()   ? 1u : 0u) << 2;
             osPlatform |= (OperatingSystem.IsWindows() ? 1u : 0u) << 3;
+#pragma warning restore IDE0055
 
             return osPlatform;
         }
@@ -1025,14 +1030,14 @@ namespace ARMeilleure.Translation.PTC
             {
                 Span<OuterHeader> spanHeader = MemoryMarshal.CreateSpan(ref this, 1);
 
-                HeaderHash = XXHash128.ComputeHash(MemoryMarshal.AsBytes(spanHeader).Slice(0, Unsafe.SizeOf<OuterHeader>() - Unsafe.SizeOf<Hash128>()));
+                HeaderHash = XXHash128.ComputeHash(MemoryMarshal.AsBytes(spanHeader)[..(Unsafe.SizeOf<OuterHeader>() - Unsafe.SizeOf<Hash128>())]);
             }
 
             public bool IsHeaderValid()
             {
                 Span<OuterHeader> spanHeader = MemoryMarshal.CreateSpan(ref this, 1);
 
-                return XXHash128.ComputeHash(MemoryMarshal.AsBytes(spanHeader).Slice(0, Unsafe.SizeOf<OuterHeader>() - Unsafe.SizeOf<Hash128>())) == HeaderHash;
+                return XXHash128.ComputeHash(MemoryMarshal.AsBytes(spanHeader)[..(Unsafe.SizeOf<OuterHeader>() - Unsafe.SizeOf<Hash128>())]) == HeaderHash;
             }
         }
 
@@ -1060,14 +1065,14 @@ namespace ARMeilleure.Translation.PTC
             {
                 Span<InnerHeader> spanHeader = MemoryMarshal.CreateSpan(ref this, 1);
 
-                HeaderHash = XXHash128.ComputeHash(MemoryMarshal.AsBytes(spanHeader).Slice(0, Unsafe.SizeOf<InnerHeader>() - Unsafe.SizeOf<Hash128>()));
+                HeaderHash = XXHash128.ComputeHash(MemoryMarshal.AsBytes(spanHeader)[..(Unsafe.SizeOf<InnerHeader>() - Unsafe.SizeOf<Hash128>())]);
             }
 
             public bool IsHeaderValid()
             {
                 Span<InnerHeader> spanHeader = MemoryMarshal.CreateSpan(ref this, 1);
 
-                return XXHash128.ComputeHash(MemoryMarshal.AsBytes(spanHeader).Slice(0, Unsafe.SizeOf<InnerHeader>() - Unsafe.SizeOf<Hash128>())) == HeaderHash;
+                return XXHash128.ComputeHash(MemoryMarshal.AsBytes(spanHeader)[..(Unsafe.SizeOf<InnerHeader>() - Unsafe.SizeOf<Hash128>())]) == HeaderHash;
             }
         }
 
diff --git a/src/ARMeilleure/Translation/PTC/PtcFormatter.cs b/src/ARMeilleure/Translation/PTC/PtcFormatter.cs
index 2f7a9c21..ddac3133 100644
--- a/src/ARMeilleure/Translation/PTC/PtcFormatter.cs
+++ b/src/ARMeilleure/Translation/PTC/PtcFormatter.cs
@@ -47,7 +47,7 @@ namespace ARMeilleure.Translation.PTC
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static T DeserializeStructure<T>(Stream stream) where T : struct
         {
-            T structure = default(T);
+            T structure = default;
 
             Span<T> spanT = MemoryMarshal.CreateSpan(ref structure, 1);
             int bytesCount = stream.Read(MemoryMarshal.AsBytes(spanT));
@@ -176,4 +176,4 @@ namespace ARMeilleure.Translation.PTC
         }
         #endregion
     }
-}
\ No newline at end of file
+}
diff --git a/src/ARMeilleure/Translation/PTC/PtcLoadingState.cs b/src/ARMeilleure/Translation/PTC/PtcLoadingState.cs
index 526cf91f..587be793 100644
--- a/src/ARMeilleure/Translation/PTC/PtcLoadingState.cs
+++ b/src/ARMeilleure/Translation/PTC/PtcLoadingState.cs
@@ -4,6 +4,6 @@ namespace ARMeilleure.Translation.PTC
     {
         Start,
         Loading,
-        Loaded
+        Loaded,
     }
-}
\ No newline at end of file
+}
diff --git a/src/ARMeilleure/Translation/PTC/PtcProfiler.cs b/src/ARMeilleure/Translation/PTC/PtcProfiler.cs
index 391e29c7..3a4bfcec 100644
--- a/src/ARMeilleure/Translation/PTC/PtcProfiler.cs
+++ b/src/ARMeilleure/Translation/PTC/PtcProfiler.cs
@@ -12,7 +12,6 @@ using System.IO.Compression;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Threading;
-
 using static ARMeilleure.Translation.PTC.PtcFormatter;
 
 namespace ARMeilleure.Translation.PTC
@@ -46,7 +45,7 @@ namespace ARMeilleure.Translation.PTC
         public bool Enabled { get; private set; }
 
         public ulong StaticCodeStart { get; set; }
-        public ulong StaticCodeSize  { get; set; }
+        public ulong StaticCodeSize { get; set; }
 
         public PtcProfiler(Ptc ptc)
         {
@@ -129,8 +128,8 @@ namespace ARMeilleure.Translation.PTC
             string fileNameActual = $"{_ptc.CachePathActual}.info";
             string fileNameBackup = $"{_ptc.CachePathBackup}.info";
 
-            FileInfo fileInfoActual = new FileInfo(fileNameActual);
-            FileInfo fileInfoBackup = new FileInfo(fileNameBackup);
+            FileInfo fileInfoActual = new(fileNameActual);
+            FileInfo fileInfoBackup = new(fileNameBackup);
 
             if (fileInfoActual.Exists && fileInfoActual.Length != 0L)
             {
@@ -183,42 +182,40 @@ namespace ARMeilleure.Translation.PTC
                     return false;
                 }
 
-                using (MemoryStream stream = MemoryStreamManager.Shared.GetStream())
-                {
-                    Debug.Assert(stream.Seek(0L, SeekOrigin.Begin) == 0L && stream.Length == 0L);
+                using MemoryStream stream = MemoryStreamManager.Shared.GetStream();
+                Debug.Assert(stream.Seek(0L, SeekOrigin.Begin) == 0L && stream.Length == 0L);
 
-                    try
-                    {
-                        deflateStream.CopyTo(stream);
-                    }
-                    catch
-                    {
-                        InvalidateCompressedStream(compressedStream);
+                try
+                {
+                    deflateStream.CopyTo(stream);
+                }
+                catch
+                {
+                    InvalidateCompressedStream(compressedStream);
 
-                        return false;
-                    }
+                    return false;
+                }
 
-                    Debug.Assert(stream.Position == stream.Length);
+                Debug.Assert(stream.Position == stream.Length);
 
-                    stream.Seek(0L, SeekOrigin.Begin);
+                stream.Seek(0L, SeekOrigin.Begin);
 
-                    Hash128 expectedHash = DeserializeStructure<Hash128>(stream);
+                Hash128 expectedHash = DeserializeStructure<Hash128>(stream);
 
-                    Hash128 actualHash = XXHash128.ComputeHash(GetReadOnlySpan(stream));
+                Hash128 actualHash = XXHash128.ComputeHash(GetReadOnlySpan(stream));
 
-                    if (actualHash != expectedHash)
-                    {
-                        InvalidateCompressedStream(compressedStream);
+                if (actualHash != expectedHash)
+                {
+                    InvalidateCompressedStream(compressedStream);
 
-                        return false;
-                    }
+                    return false;
+                }
 
-                    ProfiledFuncs = Deserialize(stream);
+                ProfiledFuncs = Deserialize(stream);
 
-                    Debug.Assert(stream.Position == stream.Length);
+                Debug.Assert(stream.Position == stream.Length);
 
-                    _lastHash = actualHash;
-                }
+                _lastHash = actualHash;
             }
 
             long fileSize = new FileInfo(fileName).Length;
@@ -233,12 +230,12 @@ namespace ARMeilleure.Translation.PTC
             return DeserializeDictionary<ulong, FuncProfile>(stream, (stream) => DeserializeStructure<FuncProfile>(stream));
         }
 
-        private ReadOnlySpan<byte> GetReadOnlySpan(MemoryStream memoryStream)
+        private static ReadOnlySpan<byte> GetReadOnlySpan(MemoryStream memoryStream)
         {
             return new(memoryStream.GetBuffer(), (int)memoryStream.Position, (int)memoryStream.Length - (int)memoryStream.Position);
         }
 
-        private void InvalidateCompressedStream(FileStream compressedStream)
+        private static void InvalidateCompressedStream(FileStream compressedStream)
         {
             compressedStream.SetLength(0L);
         }
@@ -250,7 +247,7 @@ namespace ARMeilleure.Translation.PTC
             string fileNameActual = $"{_ptc.CachePathActual}.info";
             string fileNameBackup = $"{_ptc.CachePathBackup}.info";
 
-            FileInfo fileInfoActual = new FileInfo(fileNameActual);
+            FileInfo fileInfoActual = new(fileNameActual);
 
             if (fileInfoActual.Exists && fileInfoActual.Length != 0L)
             {
@@ -266,12 +263,13 @@ namespace ARMeilleure.Translation.PTC
         {
             int profiledFuncsCount;
 
-            OuterHeader outerHeader = new OuterHeader();
-
-            outerHeader.Magic = _outerHeaderMagic;
+            OuterHeader outerHeader = new()
+            {
+                Magic = _outerHeaderMagic,
 
-            outerHeader.InfoFileVersion = InternalVersion;
-            outerHeader.Endianness = Ptc.GetEndianness();
+                InfoFileVersion = InternalVersion,
+                Endianness = Ptc.GetEndianness(),
+            };
 
             outerHeader.SetHeaderHash();
 
@@ -301,28 +299,26 @@ namespace ARMeilleure.Translation.PTC
                     return;
                 }
 
-                using (FileStream compressedStream = new(fileName, FileMode.OpenOrCreate))
-                using (DeflateStream deflateStream = new(compressedStream, SaveCompressionLevel, true))
+                using FileStream compressedStream = new(fileName, FileMode.OpenOrCreate);
+                using DeflateStream deflateStream = new(compressedStream, SaveCompressionLevel, true);
+                try
                 {
-                    try
-                    {
-                        SerializeStructure(compressedStream, outerHeader);
+                    SerializeStructure(compressedStream, outerHeader);
 
-                        stream.WriteTo(deflateStream);
+                    stream.WriteTo(deflateStream);
 
-                        _lastHash = hash;
-                    }
-                    catch
-                    {
-                        compressedStream.Position = 0L;
+                    _lastHash = hash;
+                }
+                catch
+                {
+                    compressedStream.Position = 0L;
 
-                        _lastHash = default;
-                    }
+                    _lastHash = default;
+                }
 
-                    if (compressedStream.Position < compressedStream.Length)
-                    {
-                        compressedStream.SetLength(compressedStream.Position);
-                    }
+                if (compressedStream.Position < compressedStream.Length)
+                {
+                    compressedStream.SetLength(compressedStream.Position);
                 }
             }
 
@@ -334,7 +330,7 @@ namespace ARMeilleure.Translation.PTC
             }
         }
 
-        private void Serialize(Stream stream, Dictionary<ulong, FuncProfile> profiledFuncs)
+        private static void Serialize(Stream stream, Dictionary<ulong, FuncProfile> profiledFuncs)
         {
             SerializeDictionary(stream, profiledFuncs, (stream, structure) => SerializeStructure(stream, structure));
         }
@@ -354,14 +350,14 @@ namespace ARMeilleure.Translation.PTC
             {
                 Span<OuterHeader> spanHeader = MemoryMarshal.CreateSpan(ref this, 1);
 
-                HeaderHash = XXHash128.ComputeHash(MemoryMarshal.AsBytes(spanHeader).Slice(0, Unsafe.SizeOf<OuterHeader>() - Unsafe.SizeOf<Hash128>()));
+                HeaderHash = XXHash128.ComputeHash(MemoryMarshal.AsBytes(spanHeader)[..(Unsafe.SizeOf<OuterHeader>() - Unsafe.SizeOf<Hash128>())]);
             }
 
             public bool IsHeaderValid()
             {
                 Span<OuterHeader> spanHeader = MemoryMarshal.CreateSpan(ref this, 1);
 
-                return XXHash128.ComputeHash(MemoryMarshal.AsBytes(spanHeader).Slice(0, Unsafe.SizeOf<OuterHeader>() - Unsafe.SizeOf<Hash128>())) == HeaderHash;
+                return XXHash128.ComputeHash(MemoryMarshal.AsBytes(spanHeader)[..(Unsafe.SizeOf<OuterHeader>() - Unsafe.SizeOf<Hash128>())]) == HeaderHash;
             }
         }
 
@@ -418,4 +414,4 @@ namespace ARMeilleure.Translation.PTC
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/ARMeilleure/Translation/PTC/PtcState.cs b/src/ARMeilleure/Translation/PTC/PtcState.cs
index ca4f4108..f6692e87 100644
--- a/src/ARMeilleure/Translation/PTC/PtcState.cs
+++ b/src/ARMeilleure/Translation/PTC/PtcState.cs
@@ -5,6 +5,6 @@ namespace ARMeilleure.Translation.PTC
         Enabled,
         Continuing,
         Closing,
-        Disabled
+        Disabled,
     }
-}
\ No newline at end of file
+}