remove default accessibility modifiers

Author: ssg

.editorconfig

@@ -98,6 +98,8 @@ dotnet_diagnostic.SA1009.severity = none
 csharp_style_prefer_primary_constructors = true:suggestion
 csharp_prefer_system_threading_lock = true:suggestion
 csharp_style_prefer_unbound_generic_type_in_nameof = true:suggestion
+csharp_style_allow_blank_line_after_token_in_conditional_expression_experimental = true:silent
+csharp_style_allow_blank_line_after_token_in_arrow_expression_clause_experimental = true:silent
 
 [*.vb]
 #### Naming styles ####
@@ -176,8 +178,8 @@ end_of_line = crlf
 dotnet_style_readonly_field = true:suggestion
 dotnet_style_predefined_type_for_member_access = true:silent
 dotnet_style_predefined_type_for_locals_parameters_members = true:silent
-dotnet_style_require_accessibility_modifiers = for_non_interface_members:silent
-dotnet_style_allow_multiple_blank_lines_experimental = true:silent
+dotnet_style_require_accessibility_modifiers = omit_if_default:warning
+dotnet_style_allow_multiple_blank_lines_experimental = false:warning
 dotnet_style_allow_statement_immediately_after_block_experimental = true:silent
 dotnet_code_quality_unused_parameters = all:suggestion
 dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity:suggestion

benchmark/BenchmarkSuite.cs

@@ -11,8 +11,8 @@ public class BenchmarkSuite
 
     public int Bits;
 
-    private static readonly byte[] buf = new byte[BufSize];
-    private static readonly byte[] sipHashKey = new byte[16];
+    static readonly byte[] buf = new byte[BufSize];
+    static readonly byte[] sipHashKey = new byte[16];
 
 #pragma warning disable IDE0079 // Remove unnecessary suppression
 #pragma warning disable CA1822 // Mark members as static - BenchmarkDotNet requires these as instance members

src/Bits.cs

@@ -12,7 +12,7 @@ namespace HashDepot;
 /// <summary>
 /// Bit operations.
 /// </summary>
-internal static class Bits
+static class Bits
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal static ulong RotateLeft(ulong value, int bits)

src/Checksum.cs

@@ -12,7 +12,7 @@ namespace HashDepot;
 /// <summary>
 /// Dummy checksum implementation for benchmark baseline. Don't use in real life.
 /// </summary>
-internal static class Checksum
+static class Checksum
 {
     public static uint Hash32(ReadOnlySpan<byte> buffer)
     {

src/Fnv1a.cs

@@ -14,11 +14,11 @@ namespace HashDepot;
 /// </summary>
 public static class Fnv1a
 {
-    private const uint offsetBasis32 = 2166136261;
-    private const uint prime32 = 16777619;
+    const uint offsetBasis32 = 2166136261;
+    const uint prime32 = 16777619;
 
-    private const ulong offsetBasis64 = 14695981039346656037;
-    private const ulong prime64 = 1099511628211;
+    const ulong offsetBasis64 = 14695981039346656037;
+    const ulong prime64 = 1099511628211;
 
     /// <summary>
     /// Calculate 32-bit FNV-1a hash value.

src/MurmurHash3.cs

@@ -280,7 +280,7 @@ public static byte[] Hash128(ReadOnlySpan<byte> buffer, uint seed)
         return makeBytes(h1, h2);
     }
 
-    private static byte[] makeBytes(ulong h1, ulong h2)
+    static byte[] makeBytes(ulong h1, ulong h2)
     {
         var result = new byte[16];
         BitConverter.TryWriteBytes(result, h1);
@@ -289,7 +289,7 @@ private static byte[] makeBytes(ulong h1, ulong h2)
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void round32(ref uint value, ref uint hash)
+static void round32(ref uint value, ref uint hash)
     {
         const uint c1 = 0xcc9e2d51;
         const uint c2 = 0x1b873593;
@@ -301,7 +301,7 @@ private static void round32(ref uint value, ref uint hash)
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void round128(
+static void round128(
         ref ulong k,
         ref ulong h,
         ulong c1,
@@ -321,7 +321,7 @@ private static void round128(
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void fmix64(ref ulong h)
+static void fmix64(ref ulong h)
     {
         h ^= h >> 33;
         h *= 0xff51afd7ed558ccdUL;
@@ -331,7 +331,7 @@ private static void fmix64(ref ulong h)
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void tailRound128(ref ulong k, ref ulong h, ulong c1, ulong c2, int rot)
+static void tailRound128(ref ulong k, ref ulong h, ulong c1, ulong c2, int rot)
     {
         k *= c1;
         k = Bits.RotateLeft(k, rot);

src/SipHash24.cs

@@ -15,14 +15,14 @@ namespace HashDepot;
 /// </summary>
 public static class SipHash24
 {
-    private const int keyLength = 16;
+    const int keyLength = 16;
 
-    private const ulong initv0 = 0x736f6d6570736575U;
-    private const ulong initv1 = 0x646f72616e646f6dU;
-    private const ulong initv2 = 0x6c7967656e657261U;
-    private const ulong initv3 = 0x7465646279746573U;
+    const ulong initv0 = 0x736f6d6570736575U;
+    const ulong initv1 = 0x646f72616e646f6dU;
+    const ulong initv2 = 0x6c7967656e657261U;
+    const ulong initv3 = 0x7465646279746573U;
 
-    private const ulong finalVectorXor = 0xFF;
+    const ulong finalVectorXor = 0xFF;
 
     /// <summary>
     /// Calculate 64-bit SipHash-2-4 algorithm using the given key and the input.
@@ -180,14 +180,14 @@ public static ulong Hash64(ReadOnlySpan<byte> buffer, ReadOnlySpan<byte> key)
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void sipRoundC(ref ulong v0, ref ulong v1, ref ulong v2, ref ulong v3)
+static void sipRoundC(ref ulong v0, ref ulong v1, ref ulong v2, ref ulong v3)
     {
         sipRound(ref v0, ref v1, ref v2, ref v3);
         sipRound(ref v0, ref v1, ref v2, ref v3);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void sipRoundD(ref ulong v0, ref ulong v1, ref ulong v2, ref ulong v3)
+static void sipRoundD(ref ulong v0, ref ulong v1, ref ulong v2, ref ulong v3)
     {
         sipRound(ref v0, ref v1, ref v2, ref v3);
         sipRound(ref v0, ref v1, ref v2, ref v3);
@@ -196,7 +196,7 @@ private static void sipRoundD(ref ulong v0, ref ulong v1, ref ulong v2, ref ulon
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void sipRound(ref ulong v0, ref ulong v1, ref ulong v2, ref ulong v3)
+static void sipRound(ref ulong v0, ref ulong v1, ref ulong v2, ref ulong v3)
     {
         v0 += v1;
         v1 = Bits.RotateLeft(v1, 13);

src/XXHash.cs

@@ -14,17 +14,17 @@ namespace HashDepot;
 /// </summary>
 public 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;
+    const ulong prime64v1 = 11400714785074694791ul;
+    const ulong prime64v2 = 14029467366897019727ul;
+    const ulong prime64v3 = 1609587929392839161ul;
+    const ulong prime64v4 = 9650029242287828579ul;
+    const ulong prime64v5 = 2870177450012600261ul;
+
+    const uint prime32v1 = 2654435761u;
+    const uint prime32v2 = 2246822519u;
+    const uint prime32v3 = 3266489917u;
+    const uint prime32v4 = 668265263u;
+    const uint prime32v5 = 374761393u;
 
     /// <summary>
     /// Generate a 32-bit xxHash value.
@@ -215,13 +215,13 @@ public static ulong Hash64(Stream stream, ulong seed = 0)
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static (ulong Acc1, ulong Acc2, ulong Acc3, ulong Acc4) initAccumulators64(ulong seed)
+static (ulong Acc1, ulong Acc2, ulong Acc3, ulong Acc4) initAccumulators64(ulong seed)
     {
         return (seed + prime64v1 + prime64v2, seed + prime64v2, seed, seed - prime64v1);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static ulong processStripe64(
+static ulong processStripe64(
         ReadOnlySpan<byte> buf,
         ref ulong acc1,
         ref ulong acc2,
@@ -246,14 +246,14 @@ private static ulong processStripe64(
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void processLane64(ref ulong accn, ReadOnlySpan<byte> buf)
+static void processLane64(ref ulong accn, ReadOnlySpan<byte> buf)
     {
         ulong lane = Bits.ToUInt64(buf);
         accn = round64(accn, lane);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static ulong processRemaining64(
+static ulong processRemaining64(
         ReadOnlySpan<byte> remaining,
         ulong acc)
     {
@@ -286,7 +286,7 @@ private static ulong processRemaining64(
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static ulong avalanche64(ulong acc)
+static ulong avalanche64(ulong acc)
     {
         acc ^= acc >> 33;
         acc *= prime64v2;
@@ -297,29 +297,29 @@ private static ulong avalanche64(ulong acc)
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static ulong round64(ulong accn, ulong lane)
+static ulong round64(ulong accn, ulong lane)
     {
         accn += lane * prime64v2;
         return Bits.RotateLeft(accn, 31) * prime64v1;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void mergeAccumulator64(ref ulong acc, ulong accn)
+static void mergeAccumulator64(ref ulong acc, ulong accn)
     {
         acc ^= round64(0, accn);
         acc *= prime64v1;
         acc += prime64v4;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static (uint Acc1, uint Acc2, uint Acc3, uint Acc4) initAccumulators32(
+static (uint Acc1, uint Acc2, uint Acc3, uint Acc4) initAccumulators32(
         uint seed)
     {
         return (seed + prime32v1 + prime32v2, seed + prime32v2, seed, seed - prime32v1);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static uint processStripe32(
+static uint processStripe32(
         ReadOnlySpan<byte> buf,
         ref uint acc1,
         ref uint acc2,
@@ -338,14 +338,14 @@ private static uint processStripe32(
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void processLane32(ReadOnlySpan<byte> buf, ref uint accn)
+static void processLane32(ReadOnlySpan<byte> buf, ref uint accn)
     {
         uint lane = Bits.ToUInt32(buf);
         accn = round32(accn, lane);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static uint processRemaining32(
+static uint processRemaining32(
         ReadOnlySpan<byte> remaining,
         uint acc)
     {
@@ -369,7 +369,7 @@ private static uint processRemaining32(
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static uint round32(uint accn, uint lane)
+static uint round32(uint accn, uint lane)
     {
         accn += lane * prime32v2;
         accn = Bits.RotateLeft(accn, 13);
@@ -378,7 +378,7 @@ private static uint round32(uint accn, uint lane)
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static uint avalanche32(uint acc)
+static uint avalanche32(uint acc)
     {
         acc ^= acc >> 15;
         acc *= prime32v2;

test/ChecksumTest.cs

@@ -6,7 +6,7 @@ namespace HashDepot.Test;
 [TestFixture]
 public class ChecksumTest
 {
-    private static readonly byte[] array = new byte[1001 * 1003];
+    static readonly byte[] array = new byte[1001 * 1003];
 
     [Test]
     public void Test()