Move the literals to be better scoped.

Author: mgravell

eng/StackExchange.Redis.Build/FastHashGenerator.cs

@@ -40,6 +40,24 @@ private bool Predicate(SyntaxNode node, CancellationToken cancellationToken)
         return false;
     }
 
+    private static string GetName(INamedTypeSymbol type)
+    {
+        if (type.ContainingType is null) return type.Name;
+        var stack = new Stack<string>();
+        while (true)
+        {
+            stack.Push(type.Name);
+            if (type.ContainingType is null) break;
+            type = type.ContainingType;
+        }
+        var sb = new StringBuilder(stack.Pop());
+        while (stack.Count != 0)
+        {
+            sb.Append('.').Append(stack.Pop());
+        }
+        return sb.ToString();
+    }
+
     private (string Namespace, string ParentType, string Name, string Value) Transform(
         GeneratorSyntaxContext ctx,
         CancellationToken cancellationToken)
@@ -49,7 +67,7 @@ private bool Predicate(SyntaxNode node, CancellationToken cancellationToken)
         string ns = "", parentType = "";
         if (named.ContainingType is { } containingType)
         {
-            parentType = containingType.Name; // don't worry about multi-level nesting for now; add later if needed
+            parentType = GetName(containingType);
             ns = containingType.ContainingNamespace.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat);
         }
         else if (named.ContainingNamespace is { } containingNamespace)
@@ -114,17 +132,33 @@ private void Generate(
         foreach (var grp in literals.GroupBy(l => (l.Namespace, l.ParentType)))
         {
             NewLine();
+            int braces = 0;
             if (!string.IsNullOrWhiteSpace(grp.Key.Namespace))
             {
                 NewLine().Append("namespace ").Append(grp.Key.Namespace);
                 NewLine().Append("{");
                 indent++;
+                braces++;
             }
             if (!string.IsNullOrWhiteSpace(grp.Key.ParentType))
             {
-                NewLine().Append("partial class ").Append(grp.Key.ParentType);
-                NewLine().Append("{");
-                indent++;
+                if (grp.Key.ParentType.Contains('.')) // nested types
+                {
+                    foreach (var part in grp.Key.ParentType.Split('.'))
+                    {
+                        NewLine().Append("partial class ").Append(part);
+                        NewLine().Append("{");
+                        indent++;
+                        braces++;
+                    }
+                }
+                else
+                {
+                    NewLine().Append("partial class ").Append(grp.Key.ParentType);
+                    NewLine().Append("{");
+                    indent++;
+                    braces++;
+                }
             }
 
             foreach (var literal in grp)
@@ -156,12 +190,8 @@ private void Generate(
                 NewLine().Append("}");
             }
 
-            if (!string.IsNullOrWhiteSpace(grp.Key.ParentType))
-            {
-                indent--;
-                NewLine().Append("}");
-            }
-            if (!string.IsNullOrWhiteSpace(grp.Key.Namespace))
+            // handle any closing braces
+            while (braces-- > 0)
             {
                 indent--;
                 NewLine().Append("}");

eng/StackExchange.Redis.Build/FastHashGenerator.md

@@ -11,7 +11,8 @@ The purpose of this generator is to interpret inputs like:
 
 Usually the token is inferred from the name; `[FastHash("real value")]` can be used if the token is not a valid identifier.
 Underscore is replaced with hyphen, so a field called `my_token` has the default value `"my-token"`.
-The generator demands *all* of `[FastHash] public static partial class`.
+The generator demands *all* of `[FastHash] public static partial class`, and note that any *containing* types must
+*also* be declared `partial`.
 
 The output is of the form:
 
@@ -34,7 +35,9 @@ static partial class f32
 }
 ```
 
-This allows for fast, efficient, and safe matching of well-known tokens, for example:
+(this API is strictly an internal implementation detail, and can change at any time)
+
+This generated code allows for fast, efficient, and safe matching of well-known tokens, for example:
 
 ``` c#
 var key = ...
@@ -52,7 +55,11 @@ switch (key.Length)
 
 The switch on the `Length` is optional, but recommended - these low values can often be implemented (by the compiler)
 as a simple jump-table, which is very fast. However, switching on the hash itself is also valid. All hash matches
-must also perform a sequence equality check - the `Is` convenient method validates both hash and equality. 
+must also perform a sequence equality check - the `Is` convenient method validates both hash and equality.
+
+Note that `switch` requires `const` values, hence why we use generated *types* rather than partial-properties
+that emit an instance with the known values. Also, the `"..."u8` syntax emits a span which is awkward to store, but
+easy to return via a property.~~~~
 
 
 

src/StackExchange.Redis/FastHash.Literals.cs

@@ -1,6 +1,6 @@
-using System;
-using System.Buffers;
+using System.Buffers;
 using System.Buffers.Binary;
+using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
@@ -11,29 +11,16 @@ namespace StackExchange.Redis;
 /// RESP literals that are usually identifiable by their length and initial bytes; it is not intended
 /// for general purpose hashing. All matches must also perform a sequence equality check.
 /// </summary>
-/// <remarks>While introduced alongside the VSET work, this is not specific to VSET - and indeed VSET
-/// is not a good example of the feature; rather, this is intended for more widespread use.</remarks>
-/*
-Example data from the benchmarks; note that string is included only for baseline purposes - we don't actually want
-to construct strings when parsing tokens.
-
-| Method               | Size | Mean      | Error     | StdDev    | Median    | Op/s          | Ratio | RatioSD | Allocated | Alloc Ratio |
-|--------------------- |----- |----------:|----------:|----------:|----------:|--------------:|------:|--------:|----------:|------------:|
-| String               | 16   | 21.376 ns | 0.4164 ns | 0.6483 ns | 21.268 ns |  46,781,518.5 |  1.00 |    0.04 |         - |          NA |
-| Hash64               | 16   |  3.161 ns | 0.0605 ns | 0.0647 ns |  3.148 ns | 316,400,326.5 |  0.15 |    0.01 |         - |          NA |
-| Hash64Unsafe         | 16   |  3.820 ns | 0.0747 ns | 0.1072 ns |  3.811 ns | 261,789,013.8 |  0.18 |    0.01 |         - |          NA |
-| Hash64Fallback       | 16   | 19.461 ns | 0.2954 ns | 0.2763 ns | 19.496 ns |  51,383,837.0 |  0.91 |    0.03 |         - |          NA |
-| Hash64_SingleSegment | 16   |  9.477 ns | 0.1877 ns | 0.3705 ns |  9.464 ns | 105,519,833.1 |  0.44 |    0.02 |         - |          NA |
-| Hash64_MultiSegment  | 16   | 82.778 ns | 1.6255 ns | 2.3313 ns | 82.475 ns |  12,080,568.6 |  3.88 |    0.16 |         - |          NA |
-*/
-internal static partial class FastHash
+/// <remarks>See HastHashGenerator.md for more information and intended usage.</remarks>
+[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
+[Conditional("DEBUG")] // evaporate in release
+internal sealed class FastHashAttribute(string token = "") : Attribute
 {
-    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
-    public sealed class FastHashAttribute(string token = "") : Attribute
-    {
-        public string Token => token;
-    }
+    public string Token => token;
+}
 
+internal static class FastHash
+{
     // Perform case-insensitive hash by masking (X and x differ by only 1 bit); this halves
     // our entropy, but is still useful when case doesn't matter.
     private const long CaseMask = ~0x2020202020202020;

src/StackExchange.Redis/FastHash.cs

@@ -1,5 +1,4 @@
 using Pipelines.Sockets.Unofficial.Arenas;
-using FH = global::StackExchange.Redis.FastHash;
 
 // ReSharper disable once CheckNamespace
 namespace StackExchange.Redis;
@@ -44,7 +43,7 @@ protected override bool TryReadOne(in RawResult result, out RedisValue value)
         }
     }
 
-    private sealed class VectorSetInfoProcessor : ResultProcessor<VectorSetInfo?>
+    private sealed partial class VectorSetInfoProcessor : ResultProcessor<VectorSetInfo?>
     {
         protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result)
         {
@@ -59,7 +58,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
                 var quantType = VectorSetQuantization.Unknown;
                 string? quantTypeRaw = null;
                 int vectorDim = 0, maxLevel = 0;
-                long size = 0, vsetUid = 0, hnswMaxNodeUid = 0;
+                long resultSize = 0, vsetUid = 0, hnswMaxNodeUid = 0;
                 var iter = result.GetItems().GetEnumerator();
                 while (iter.MoveNext())
                 {
@@ -71,30 +70,30 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
                     var keyHash = key.Payload.Hash64();
                     switch (key.Payload.Length)
                     {
-                        case FH.size.Length when FH.size.Is(keyHash, key) && value.TryGetInt64(out var i64):
-                            size = i64;
+                        case size.Length when size.Is(keyHash, key) && value.TryGetInt64(out var i64):
+                            resultSize = i64;
                             break;
-                        case FH.vset_uid.Length when FH.vset_uid.Is(keyHash, key) && value.TryGetInt64(out var i64):
+                        case vset_uid.Length when vset_uid.Is(keyHash, key) && value.TryGetInt64(out var i64):
                             vsetUid = i64;
                             break;
-                        case FH.max_level.Length when FH.max_level.Is(keyHash, key) && value.TryGetInt64(out var i64):
+                        case max_level.Length when max_level.Is(keyHash, key) && value.TryGetInt64(out var i64):
                             maxLevel = checked((int)i64);
                             break;
-                        case FH.vector_dim.Length
-                            when FH.vector_dim.Is(keyHash, key) && value.TryGetInt64(out var i64):
+                        case vector_dim.Length
+                            when vector_dim.Is(keyHash, key) && value.TryGetInt64(out var i64):
                             vectorDim = checked((int)i64);
                             break;
-                        case FH.quant_type.Length when FH.quant_type.Is(keyHash, key):
+                        case quant_type.Length when quant_type.Is(keyHash, key):
                             var qHash = value.Payload.Hash64();
                             switch (value.Payload.Length)
                             {
-                                case FH.bin.Length when FH.bin.Is(qHash, value):
+                                case bin.Length when bin.Is(qHash, value):
                                     quantType = VectorSetQuantization.Binary;
                                     break;
-                                case FH.f32.Length when FH.f32.Is(qHash, value):
+                                case f32.Length when f32.Is(qHash, value):
                                     quantType = VectorSetQuantization.None;
                                     break;
-                                case FH.int8.Length when FH.int8.Is(qHash, value):
+                                case int8.Length when int8.Is(qHash, value):
                                     quantType = VectorSetQuantization.Int8;
                                     break;
                                 default:
@@ -104,20 +103,34 @@ when FH.vector_dim.Is(keyHash, key) && value.TryGetInt64(out var i64):
                             }
 
                             break;
-                        case FH.hnsw_max_node_uid.Length
-                            when FH.hnsw_max_node_uid.Is(keyHash, key) && value.TryGetInt64(out var i64):
+                        case hnsw_max_node_uid.Length
+                            when hnsw_max_node_uid.Is(keyHash, key) && value.TryGetInt64(out var i64):
                             hnswMaxNodeUid = i64;
                             break;
                     }
                 }
 
                 SetResult(
                     message,
-                    new VectorSetInfo(quantType, quantTypeRaw, vectorDim, size, maxLevel, vsetUid, hnswMaxNodeUid));
+                    new VectorSetInfo(quantType, quantTypeRaw, vectorDim, resultSize, maxLevel, vsetUid, hnswMaxNodeUid));
                 return true;
             }
 
             return false;
         }
+
+#pragma warning disable CS8981, SA1134, SA1300, SA1303, SA1502
+        // ReSharper disable InconsistentNaming - to better represent expected literals
+        [FastHash] public static partial class bin { }
+        [FastHash] public static partial class f32 { }
+        [FastHash] public static partial class int8 { }
+        [FastHash] public static partial class size { }
+        [FastHash] public static partial class vset_uid { }
+        [FastHash] public static partial class max_level { }
+        [FastHash] public static partial class quant_type { }
+        [FastHash] public static partial class vector_dim { }
+        [FastHash] public static partial class hnsw_max_node_uid { }
+        // ReSharper restore InconsistentNaming
+#pragma warning restore CS8981, SA1134, SA1300, SA1303, SA1502
     }
 }