refactor!: reformat source files, apply Unity standards

com.unity.multiplayer.mlapi/Editor/CodeGen/CodeGenHelpers.cs

@@ -88,9 +88,8 @@ public static bool HasInterface(this TypeReference typeReference, string Interfa
             }
             catch
             {
+                return false;
             }
-
-            return false;
         }
 
         public static bool IsSerializable(this TypeReference typeReference)
@@ -141,16 +140,12 @@ public static TypeReference GetEnumAsInt(this TypeReference typeReference)
             try
             {
                 var typeDef = typeReference.Resolve();
-                if (typeDef.IsEnum)
-                {
-                    return typeDef.GetEnumUnderlyingType();
-                }
+                return typeDef.IsEnum ? typeDef.GetEnumUnderlyingType() : null;
             }
             catch
             {
+                return null;
             }
-
-            return null;
         }
 
         public static void AddError(this List<DiagnosticMessage> diagnostics, string message)

com.unity.multiplayer.mlapi/Editor/CodeGen/ILPostProcessorProgram.cs

@@ -37,7 +37,7 @@ private static ILPostProcessor[] FindAllPostProcessors()
                 }
                 catch (Exception exception)
                 {
-                    Debug.LogError($"Could not create ILPostProcessor ({typeCollection.FullName}):{Environment.NewLine}{exception.StackTrace}");
+                    Debug.LogError($"Could not create {nameof(ILPostProcessor)} ({typeCollection.FullName}):{Environment.NewLine}{exception.StackTrace}");
                 }
             }
 
@@ -185,22 +185,21 @@ void WriteAssembly(InMemoryAssembly inMemoryAssembly, string outputPath, string
             foreach (var i in s_ILPostProcessors)
             {
                 var result = i.Process(targetCompiledAssembly);
-                if (result == null)
-                    continue;
+                if (result == null) continue;
 
                 if (result.Diagnostics.Count > 0)
                 {
-                    Debug.LogError($"ILPostProcessor - {i.GetType().Name} failed to run on {targetCompiledAssembly.Name}");
+                    Debug.LogError($"{nameof(ILPostProcessor)} - {i.GetType().Name} failed to run on {targetCompiledAssembly.Name}");
 
                     foreach (var message in result.Diagnostics)
                     {
                         switch (message.DiagnosticType)
                         {
                             case DiagnosticType.Error:
-                                Debug.LogError($"ILPostProcessor Error - {message.MessageData} {message.File}:{message.Line}");
+                                Debug.LogError($"{nameof(ILPostProcessor)} Error - {message.MessageData} {message.File}:{message.Line}");
                                 break;
                             case DiagnosticType.Warning:
-                                Debug.LogWarning($"ILPostProcessor Warning - {message.MessageData} {message.File}:{message.Line}");
+                                Debug.LogWarning($"{nameof(ILPostProcessor)} Warning - {message.MessageData} {message.File}:{message.Line}");
                                 break;
                         }
                     }

com.unity.multiplayer.mlapi/Editor/CodeGen/PostProcessorReflectionImporter.cs

@@ -6,17 +6,17 @@ namespace MLAPI.Editor.CodeGen
 {
     internal class PostProcessorReflectionImporter : DefaultReflectionImporter
     {
-        private const string SystemPrivateCoreLib = "System.Private.CoreLib";
+        private const string k_SystemPrivateCoreLib = "System.Private.CoreLib";
         private readonly AssemblyNameReference m_CorrectCorlib;
 
         public PostProcessorReflectionImporter(ModuleDefinition module) : base(module)
         {
-            m_CorrectCorlib = module.AssemblyReferences.FirstOrDefault(a => a.Name == "mscorlib" || a.Name == "netstandard" || a.Name == SystemPrivateCoreLib);
+            m_CorrectCorlib = module.AssemblyReferences.FirstOrDefault(a => a.Name == "mscorlib" || a.Name == "netstandard" || a.Name == k_SystemPrivateCoreLib);
         }
 
         public override AssemblyNameReference ImportReference(AssemblyName reference)
         {
-            return m_CorrectCorlib != null && reference.Name == SystemPrivateCoreLib ? m_CorrectCorlib : base.ImportReference(reference);
+            return m_CorrectCorlib != null && reference.Name == k_SystemPrivateCoreLib ? m_CorrectCorlib : base.ImportReference(reference);
         }
     }
 }

com.unity.multiplayer.mlapi/Editor/CodeGen/XXHash/XXHash.cs

@@ -14,17 +14,17 @@ namespace MLAPI.Editor.CodeGen
     /// </summary>
     internal static class XXHash
     {
-        private const ulong prime64v1 = 11400714785074694791ul;
-        private const ulong prime64v2 = 14029467366897019727ul;
-        private const ulong prime64v3 = 1609587929392839161ul;
-        private const ulong prime64v4 = 9650029242287828579ul;
-        private const ulong prime64v5 = 2870177450012600261ul;
-
-        private const uint prime32v1 = 2654435761u;
-        private const uint prime32v2 = 2246822519u;
-        private const uint prime32v3 = 3266489917u;
-        private const uint prime32v4 = 668265263u;
-        private const uint prime32v5 = 374761393u;
+        private const ulong k_Prime64v1 = 11400714785074694791ul;
+        private const ulong k_Prime64v2 = 14029467366897019727ul;
+        private const ulong k_Prime64v3 = 1609587929392839161ul;
+        private const ulong k_Prime64v4 = 9650029242287828579ul;
+        private const ulong k_Prime64v5 = 2870177450012600261ul;
+
+        private const uint k_Prime32v1 = 2654435761u;
+        private const uint k_Prime32v2 = 2246822519u;
+        private const uint k_Prime32v3 = 3266489917u;
+        private const uint k_Prime32v4 = 668265263u;
+        private const uint k_Prime32v5 = 374761393u;
 
         /// <summary>
         /// Generate a 32-bit xxHash value.
@@ -44,10 +44,10 @@ public static unsafe uint Hash32(byte* buffer, int bufferLength, uint seed = 0)
             byte* pInput = buffer;
             if (len >= stripeLength)
             {
-                uint acc1 = seed + prime32v1 + prime32v2;
-                uint acc2 = seed + prime32v2;
+                uint acc1 = seed + k_Prime32v1 + k_Prime32v2;
+                uint acc2 = seed + k_Prime32v2;
                 uint acc3 = seed;
-                uint acc4 = seed - prime32v1;
+                uint acc4 = seed - k_Prime32v1;
 
                 do
                 {
@@ -57,7 +57,7 @@ public static unsafe uint Hash32(byte* buffer, int bufferLength, uint seed = 0)
             }
             else
             {
-                acc = seed + prime32v5;
+                acc = seed + k_Prime32v5;
             }
 
             acc += (uint)len;
@@ -84,10 +84,10 @@ public static unsafe ulong Hash64(byte* buffer, int bufferLength, ulong seed = 0
             byte* pInput = buffer;
             if (len >= stripeLength)
             {
-                ulong acc1 = seed + prime64v1 + prime64v2;
-                ulong acc2 = seed + prime64v2;
+                ulong acc1 = seed + k_Prime64v1 + k_Prime64v2;
+                ulong acc2 = seed + k_Prime64v2;
                 ulong acc3 = seed;
-                ulong acc4 = seed - prime64v1;
+                ulong acc4 = seed - k_Prime64v1;
 
                 do
                 {
@@ -97,7 +97,7 @@ public static unsafe ulong Hash64(byte* buffer, int bufferLength, ulong seed = 0
             }
             else
             {
-                acc = seed + prime64v5;
+                acc = seed + k_Prime64v5;
             }
 
             acc += (ulong)len;
@@ -151,24 +151,24 @@ private static unsafe ulong processRemaining64(
                 lane = *(ulong*)pInput;
 
                 acc ^= round64(0, lane);
-                acc = Bits.RotateLeft(acc, 27) * prime64v1;
-                acc += prime64v4;
+                acc = Bits.RotateLeft(acc, 27) * k_Prime64v1;
+                acc += k_Prime64v4;
             }
 
             for (uint lane32; remainingLen >= 4; remainingLen -= 4, pInput += 4)
             {
                 lane32 = *(uint*)pInput;
 
-                acc ^= lane32 * prime64v1;
-                acc = Bits.RotateLeft(acc, 23) * prime64v2;
-                acc += prime64v3;
+                acc ^= lane32 * k_Prime64v1;
+                acc = Bits.RotateLeft(acc, 23) * k_Prime64v2;
+                acc += k_Prime64v3;
             }
 
             for (byte lane8; remainingLen >= 1; remainingLen--, pInput++)
             {
                 lane8 = *pInput;
-                acc ^= lane8 * prime64v5;
-                acc = Bits.RotateLeft(acc, 11) * prime64v1;
+                acc ^= lane8 * k_Prime64v5;
+                acc = Bits.RotateLeft(acc, 11) * k_Prime64v1;
             }
 
             return acc;
@@ -178,26 +178,26 @@ private static unsafe ulong processRemaining64(
         private static ulong avalanche64(ulong acc)
         {
             acc ^= acc >> 33;
-            acc *= prime64v2;
+            acc *= k_Prime64v2;
             acc ^= acc >> 29;
-            acc *= prime64v3;
+            acc *= k_Prime64v3;
             acc ^= acc >> 32;
             return acc;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static ulong round64(ulong accn, ulong lane)
         {
-            accn += lane * prime64v2;
-            return Bits.RotateLeft(accn, 31) * prime64v1;
+            accn += lane * k_Prime64v2;
+            return Bits.RotateLeft(accn, 31) * k_Prime64v1;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static void mergeAccumulator64(ref ulong acc, ulong accn)
         {
             acc ^= round64(0, accn);
-            acc *= prime64v1;
-            acc += prime64v4;
+            acc *= k_Prime64v1;
+            acc += k_Prime64v4;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -236,15 +236,15 @@ private static unsafe uint processRemaining32(
             for (uint lane; remainingLen >= 4; remainingLen -= 4, pInput += 4)
             {
                 lane = *(uint*)pInput;
-                acc += lane * prime32v3;
-                acc = Bits.RotateLeft(acc, 17) * prime32v4;
+                acc += lane * k_Prime32v3;
+                acc = Bits.RotateLeft(acc, 17) * k_Prime32v4;
             }
 
             for (byte lane; remainingLen >= 1; remainingLen--, pInput++)
             {
                 lane = *pInput;
-                acc += lane * prime32v5;
-                acc = Bits.RotateLeft(acc, 11) * prime32v1;
+                acc += lane * k_Prime32v5;
+                acc = Bits.RotateLeft(acc, 11) * k_Prime32v1;
             }
 
             return acc;
@@ -253,19 +253,19 @@ private static unsafe uint processRemaining32(
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static uint round32(uint accn, uint lane)
         {
-            accn += lane * prime32v2;
+            accn += lane * k_Prime32v2;
             accn = Bits.RotateLeft(accn, 13);
-            accn *= prime32v1;
+            accn *= k_Prime32v1;
             return accn;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static uint avalanche32(uint acc)
         {
             acc ^= acc >> 15;
-            acc *= prime32v2;
+            acc *= k_Prime32v2;
             acc ^= acc >> 13;
-            acc *= prime32v3;
+            acc *= k_Prime32v3;
             acc ^= acc >> 16;
             return acc;
         }