Add string hashing support for dict keys (#391)

This PR adds hashing support for strings, enabling them to be used as
dictionary keys. The implementation includes a cached hash value in the
string structure and uses the FNV-1a hashing algorithm.

Code written by claude following my precise instructions, and reviewed by me.

Author: antocuni

spy/backend/c/cwriter.py

@@ -243,7 +243,7 @@ def fmt_expr_StrConst(self, const: ast.StrConst) -> C.Expr:
         # generate the following:
         #
         #     // global declarations
-        #     static spy_Str SPY_g_str0 = {5, "hello"};
+        #     static spy_Str SPY_g_str0 = {5, 0, "hello"};
         #     ...
         #     // literal expr
         #     &SPY_g_str0 /* "hello" */
@@ -258,7 +258,7 @@ def fmt_expr_StrConst(self, const: ast.StrConst) -> C.Expr:
         v = self.cmodw.new_global_var("str")  # SPY_g_str0
         n = len(utf8)
         lit = C.Literal.from_bytes(utf8)
-        init = "{%d, %s}" % (n, lit)
+        init = "{%d, 0, %s}" % (n, lit)
         self.cmodw.tbc_globals.wl(f"static spy_Str {v} = {init};")
         #
         # shortstr is what we show in the comment, with a length limit

spy/libspy/include/spy/str.h

@@ -6,6 +6,7 @@
 
 typedef struct {
     size_t length;
+    int32_t hash;
     const char utf8[];
 } spy_Str;
 
@@ -27,12 +28,15 @@ spy_Str *WASM_EXPORT(spy_str_getitem)(spy_Str *s, int32_t i);
 
 int32_t WASM_EXPORT(spy_str_len)(spy_Str *s);
 
+int32_t WASM_EXPORT(spy_str_hash)(spy_Str *s);
+
 #define spy_operator$str_add spy_str_add
 #define spy_operator$str_mul spy_str_mul
 #define spy_operator$str_eq spy_str_eq
 #define spy_operator$str_ne spy_str_ne
 #define spy_builtins$str$__getitem__ spy_str_getitem
 #define spy_builtins$str$__len__ spy_str_len
+#define spy_builtins$hash_str spy_str_hash
 
 // __str__ methods of common builtin types
 spy_Str *spy_builtins$i32$__str__(int32_t x);

spy/libspy/src/str.c

@@ -7,6 +7,7 @@ spy_str_alloc(size_t length) {
     size_t size = sizeof(spy_Str) + length;
     spy_Str *res = (spy_Str *)spy_GcAlloc(size).p;
     res->length = length;
+    res->hash = 0;
     return res;
 }
 
@@ -61,6 +62,25 @@ spy_str_len(spy_Str *s) {
     return (int32_t)s->length;
 }
 
+int32_t
+spy_str_hash(spy_Str *s) {
+    if (s->hash != 0)
+        return s->hash;
+    // FNV-1a hash
+    uint32_t h = 2166136261u;
+    for (size_t i = 0; i < s->length; i++) {
+        h ^= (uint8_t)s->utf8[i];
+        h *= 16777619u;
+    }
+    int32_t result = (int32_t)h;
+    if (result == -1)
+        result = -2;
+    if (result == 0)
+        result = 1;
+    s->hash = result;
+    return result;
+}
+
 // Helper function to format and convert to spy_Str
 // XXX probably it would be better to implement it directly, instead of
 // bringing in all the code needed to support sprintf()

spy/tests/stdlib/test_dict.py

@@ -291,6 +291,19 @@ def foo() -> dict[i32, i32]:
         x = mod.foo()
         assert x[42] == 100
 
+    def test_str_keys(self):
+        src = """
+        from _dict import dict
+
+        def test() -> i32:
+            d = dict[str, i32]()
+            d["hello"] = 1
+            d["world"] = 2
+            return d["hello"] + d["world"]
+        """
+        mod = self.compile(src)
+        assert mod.test() == 3
+
     def test_literal_mixed_value_types_key_value(self):
         # useful for mixed type support
         # type of x must be i32

spy/tests/test_libspy.py

@@ -11,11 +11,12 @@ def mk_spy_Str(utf8: bytes) -> bytes:
 
     For example, for b'hello' we have the following in-memory repr:
          <i   4 bytes of length, little endian
+         i    4 bytes of hash (0 for uncached)
          5s   5 bytes of data (b'hello')
     """
     n = len(utf8)
-    fmt = f"<i{n}s"
-    return struct.pack(fmt, n, utf8)
+    fmt = f"<ii{n}s"
+    return struct.pack(fmt, n, 0, utf8)
 
 
 class TestLibSPy(CTest):
@@ -47,7 +48,7 @@ def test_str(self):
         src = r"""
         #include <spy.h>
 
-        spy_Str H = {6, "hello "};
+        spy_Str H = {6, 0, "hello "};
 
         spy_Str *mk_W(void) {
             spy_Str *s = spy_str_alloc(5);
@@ -58,13 +59,13 @@ def test_str(self):
         test_wasm = self.c_compile(src, exports=["H", "mk_W"])
         ll = LLSPyInstance.from_file(test_wasm)
         ptr_H = ll.read_global("H")
-        assert ll.mem.read(ptr_H, 10) == mk_spy_Str(b"hello ")
+        assert ll.mem.read(ptr_H, 14) == mk_spy_Str(b"hello ")
         #
         ptr_W = ll.call("mk_W")
-        assert ll.mem.read(ptr_W, 9) == mk_spy_Str(b"world")
+        assert ll.mem.read(ptr_W, 13) == mk_spy_Str(b"world")
         #
         ptr_HW = ll.call("spy_str_add", ptr_H, ptr_W)
-        assert ll.mem.read(ptr_HW, 15) == mk_spy_Str(b"hello world")
+        assert ll.mem.read(ptr_HW, 19) == mk_spy_Str(b"hello world")
 
     def test_debug_log(self):
         src = r"""

spy/tests/wasm_wrapper.py

@@ -136,7 +136,7 @@ def to_py_result(self, w_T: W_Type, res: Any) -> Any:
             # res is a  spy_Str*
             addr = res
             length = self.ll.mem.read_i32(addr)
-            utf8 = self.ll.mem.read(addr + 4, length)
+            utf8 = self.ll.mem.read(addr + 8, length)
             return utf8.decode("utf-8")
         elif w_T is RB.w_RawBuffer:
             # res is a  spy_RawBuffer*

spy/vm/modules/builtins.py

@@ -180,6 +180,13 @@ def w_hash_bool(vm: "SPyVM", w_x: W_Bool) -> W_I32:
         assert False, "unreachable"
 
 
+@BUILTINS.builtin_func
+def w_hash_str(vm: "SPyVM", w_x: W_Str) -> W_I32:
+    assert isinstance(w_x, W_Str)
+    res = vm.ll.call("spy_str_hash", w_x.ptr)
+    return vm.wrap(res)
+
+
 @BUILTINS.builtin_func(color="blue", kind="metafunc")
 def w_hash(vm: "SPyVM", wam_obj: W_MetaArg) -> W_OpSpec:
     w_T = wam_obj.w_static_T
@@ -191,6 +198,8 @@ def w_hash(vm: "SPyVM", wam_obj: W_MetaArg) -> W_OpSpec:
         return W_OpSpec(B.w_hash_u8)
     elif w_T is B.w_bool:
         return W_OpSpec(B.w_hash_bool)
+    elif w_T is B.w_str:
+        return W_OpSpec(B.w_hash_str)
 
     if w_fn := w_T.lookup_func("__hash__"):
         w_opspec = vm.fast_metacall(w_fn, [wam_obj])

spy/vm/str.py

@@ -21,7 +21,7 @@ def ll_spy_Str_new(ll: LLWasmInstance, s: str) -> int:
     utf8 = s.encode("utf-8")
     length = len(utf8)
     ptr = ll.call("spy_str_alloc", length)
-    ll.mem.write(ptr + 4, utf8)
+    ll.mem.write(ptr + 8, utf8)
     return ptr
 
 
@@ -34,6 +34,7 @@ class W_Str(W_Object):
     resides in the linear memory of the VM:
         typedef struct {
             size_t length;
+            int32_t hash;
             const char utf8[];
         } spy_Str;
     """
@@ -59,7 +60,7 @@ def get_length(self) -> int:
 
     def get_utf8(self) -> bytes:
         length = self.get_length()
-        ba = self.vm.ll.mem.read(self.ptr + 4, length)
+        ba = self.vm.ll.mem.read(self.ptr + 8, length)
         return bytes(ba)
 
     def _as_str(self) -> str: