Move several str methods from C to applevel (#556)

Now we have enough machinery around to move most str methods to
_str.spy.
I decided to leave `str_eq`/`str_ne` in C mostly for performance
reasons: I admit it's just a gut feeling, but I suppose that `==` is the
most common operation on strings.

Author: antocuni

spy/libspy/include/spy/str.h

@@ -95,42 +95,19 @@ spy_unsafe$_alloc_StrObject$impl(int32_t length) {
     return spy_unsafe$gc_ptr___str$StrObject_from_addr(spy_str_alloc((size_t)length));
 }
 
-spy_StrObject *WASM_EXPORT(spy_str_add)(spy_StrObject *a, spy_StrObject *b);
-
-spy_StrObject *WASM_EXPORT(spy_str_replace)(
-    spy_StrObject *original,
-    spy_StrObject *old,
-    spy_StrObject *new_str
-);
-
-spy_StrObject *WASM_EXPORT(spy_str_mul)(spy_StrObject *a, int32_t b);
-
 bool WASM_EXPORT(spy_str_eq)(spy_StrObject *a, spy_StrObject *b);
 
 static inline bool
 spy_str_ne(spy_StrObject *a, spy_StrObject *b) {
     return !spy_str_eq(a, b);
 }
 
-// XXX: should we introduce a separate type Char?
-spy_StrObject *WASM_EXPORT(spy_str_getitem)(spy_StrObject *s, int32_t i);
-
-int32_t WASM_EXPORT(spy_str_len)(spy_StrObject *s);
-
-spy_StrObject *WASM_EXPORT(spy_str_repr)(spy_StrObject *s);
-
 int32_t WASM_EXPORT(spy_str_hash)(spy_StrObject *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_operator$str_to_complex128 spy_str_to_complex128
-#define spy_builtins$str$replace spy_str_replace
-#define spy_builtins$str$__getitem__ spy_str_getitem
-#define spy_builtins$str$__len__ spy_str_len
 #define spy_builtins$str$__str__ spy_str_identity
-#define spy_builtins$str$__repr__ spy_str_repr
 
 static inline spy_StrObject *
 spy_str_identity(spy_StrObject *s) {

spy/libspy/src/str.c

@@ -30,178 +30,13 @@ spy_str_alloc(size_t length) {
     return res;
 }
 
-spy_StrObject *
-spy_str_add(spy_StrObject *a, spy_StrObject *b) {
-    size_t l = a->length + b->length;
-    spy_StrObject *res = spy_str_alloc(l);
-    char *buf = (char *)spy_StrObject_UTF8(res);
-    memcpy(buf, spy_StrObject_UTF8(a), a->length);
-    memcpy(buf + a->length, spy_StrObject_UTF8(b), b->length);
-    return res;
-}
-
-spy_StrObject *
-spy_str_replace(spy_StrObject *original, spy_StrObject *old, spy_StrObject *new_str) {
-    size_t orig_len = original->length;
-    size_t old_len = old->length;
-    size_t new_len = new_str->length;
-
-    if (old_len == 0) {
-        // when old_len is empty insert new_str before each byte and after the last
-        size_t result_len = orig_len + (orig_len + 1) * new_len;
-        spy_StrObject *res = spy_str_alloc(result_len);
-        char *buf = (char *)spy_StrObject_UTF8(res);
-        for (size_t i = 0; i < orig_len; i++) {
-            memcpy(buf, spy_StrObject_UTF8(new_str), new_len);
-            buf += new_len;
-            buf[0] = spy_StrObject_UTF8(original)[i];
-            buf++;
-        }
-        memcpy(buf, spy_StrObject_UTF8(new_str), new_len);
-        return res;
-    }
-
-    // First pass -> count occurrences
-    size_t count = 0;
-    const char *p = (const char *)spy_StrObject_UTF8(original);
-    const char *end = p + orig_len;
-    while (p <= end - old_len) {
-        if (memcmp(p, spy_StrObject_UTF8(old), old_len) == 0) {
-            count++;
-            p += old_len;
-        } else {
-            p++;
-        }
-    }
-
-    if (count == 0) {
-        // Return the original string when no occurrences are found
-        spy_StrObject *res = spy_str_alloc(orig_len);
-        memcpy((char *)spy_StrObject_UTF8(res), spy_StrObject_UTF8(original), orig_len);
-        return res;
-    }
-
-    // Second pass -> build the result
-    size_t result_len = orig_len + count * (new_len - old_len);
-    spy_StrObject *res = spy_str_alloc(result_len);
-    char *buf = (char *)spy_StrObject_UTF8(res);
-    p = (const char *)spy_StrObject_UTF8(original);
-    while (p <= end - old_len) {
-        if (memcmp(p, spy_StrObject_UTF8(old), old_len) == 0) {
-            memcpy(buf, spy_StrObject_UTF8(new_str), new_len);
-            buf += new_len;
-            p += old_len;
-        } else {
-            *buf++ = *p++;
-        }
-    }
-    // Copy remaining bytes
-    size_t remaining = end - p;
-    memcpy(buf, p, remaining);
-    return res;
-}
-
-spy_StrObject *
-spy_str_mul(spy_StrObject *a, int32_t b) {
-    size_t l = a->length * b;
-    spy_StrObject *res = spy_str_alloc(l);
-    char *buf = (char *)spy_StrObject_UTF8(res);
-    for (int i = 0; i < b; i++) {
-        memcpy(buf, spy_StrObject_UTF8(a), a->length);
-        buf += a->length;
-    }
-    return res;
-}
-
 bool
 spy_str_eq(spy_StrObject *a, spy_StrObject *b) {
     if (a->length != b->length)
         return false;
     return memcmp(spy_StrObject_UTF8(a), spy_StrObject_UTF8(b), a->length) == 0;
 }
 
-spy_StrObject *
-spy_str_getitem(spy_StrObject *s, int32_t i) {
-    // XXX this is wrong: it should return a code point
-    size_t l = s->length;
-    if (i < 0) {
-        i += l;
-    }
-    if (i >= l || i < 0) {
-        spy_panic("IndexError", "string index out of bound", __FILE__, __LINE__);
-        return NULL;
-    }
-    spy_StrObject *res = spy_str_alloc(1);
-    char *buf = (char *)spy_StrObject_UTF8(res);
-    buf[0] = spy_StrObject_UTF8(s)[i];
-    return res;
-}
-
-int32_t
-spy_str_len(spy_StrObject *s) {
-    return (int32_t)s->length;
-}
-
-spy_StrObject *
-spy_str_repr(spy_StrObject *s) {
-    // Choose quote character: use double quotes if string contains ' but not "
-    char quote = '\'';
-    for (size_t i = 0; i < s->length; i++) {
-        if (spy_StrObject_UTF8(s)[i] == '\'') {
-            quote = '"';
-        }
-        if (spy_StrObject_UTF8(s)[i] == '"') {
-            quote = '\'';
-            break;
-        }
-    }
-
-    // First pass: calculate the output length
-    size_t out_len = 2; // for the surrounding quotes
-    for (size_t i = 0; i < s->length; i++) {
-        unsigned char c = (unsigned char)spy_StrObject_UTF8(s)[i];
-        if (c == '\\' || c == quote) {
-            out_len += 2;
-        } else if (c == '\n' || c == '\r' || c == '\t') {
-            out_len += 2;
-        } else if (c < 0x20) {
-            out_len += 4; // \xNN
-        } else {
-            out_len += 1;
-        }
-    }
-
-    // Second pass: fill the buffer
-    spy_StrObject *res = spy_str_alloc(out_len);
-    char *buf = (char *)spy_StrObject_UTF8(res);
-    *buf++ = quote;
-    for (size_t i = 0; i < s->length; i++) {
-        unsigned char c = (unsigned char)spy_StrObject_UTF8(s)[i];
-        if (c == '\\') {
-            *buf++ = '\\';
-            *buf++ = '\\';
-        } else if (c == quote) {
-            *buf++ = '\\';
-            *buf++ = quote;
-        } else if (c == '\n') {
-            *buf++ = '\\';
-            *buf++ = 'n';
-        } else if (c == '\r') {
-            *buf++ = '\\';
-            *buf++ = 'r';
-        } else if (c == '\t') {
-            *buf++ = '\\';
-            *buf++ = 't';
-        } else if (c < 0x20) {
-            buf += sprintf(buf, "\\x%02x", c);
-        } else {
-            *buf++ = c;
-        }
-    }
-    *buf++ = quote;
-    return res;
-}
-
 int32_t
 spy_str_hash(spy_StrObject *s) {
     if (s->hash != 0)

spy/tests/compiler/test_str.py

@@ -20,6 +20,19 @@ def foo() -> str:
         """)
         assert mod.foo() == "hello àèìòù"
 
+    def test_empty_str_as_StrObject(self):
+        src = """
+        from unsafe import _str_to_StrObject
+        from _str import StrObject
+
+        def get_length(s: str) -> i32:
+            data = _str_to_StrObject(s)
+            utf8 = data.utf8
+            return data.length
+        """
+        mod = self.compile(src)
+        assert mod.get_length("") == 0
+
     def test_add(self):
         mod = self.compile("""
         def foo() -> str:

spy/tests/test_cli.py

@@ -294,8 +294,8 @@ def test_build_and_execute(self, capfd):
     def test_execute_pyodide(self):
         # pyodide under node cannot access /tmp/, so we cannot try to execute
         # files which we wrote to self.tmpdir. Instead, let's try to execute
-        # examples/hello.spy
-        hello_spy = spy.ROOT.dirpath().join("examples", "hello.spy")
+        # examples/1_high_level/hello.spy
+        hello_spy = spy.ROOT.dirpath().join("examples", "1_high_level", "hello.spy")
         assert hello_spy.exists()
         res, stdout = self.run_external(PYODIDE_EXE, hello_spy)
         assert stdout == "Hello world!\n"

spy/tests/test_doppler.py

@@ -340,7 +340,7 @@ def `test::add[i32]::impl`(x: i32, y: i32) -> i32:
             return x + y
 
         def `test::add[str]::impl`(x: str, y: str) -> str:
-            return `operator::str_add`(x, y)
+            return `_str::methods::__add__`(x, y)
         """)
 
     def test_store_outer_var(self):

spy/tests/test_libspy.py

@@ -47,9 +47,6 @@ def test_str(self):
         #
         ptr_W = ll.call("mk_W")
         assert ll.read_str(ptr_W) == (5, 0, b"world")
-        #
-        ptr_HW = ll.call("spy_str_add", ptr_H, ptr_W)
-        assert ll.read_str(ptr_HW) == (11, 0, b"hello world")
 
     def test_debug_log(self):
         src = r"""

spy/vm/function.py

@@ -241,6 +241,12 @@ def is_pure(self) -> bool:
 
     _pure_fqns = {
         FQN("builtins::type::__new__"),
+        FQN("_str::methods::__add__"),
+        FQN("_str::methods::__mul__"),
+        FQN("_str::methods::__getitem__"),
+        FQN("_str::methods::__len__"),
+        FQN("_str::methods::__repr__"),
+        FQN("_str::methods::replace"),
     }
 
     def compute_inner_ns(self, args_w: Sequence[W_Object]) -> FQN:

spy/vm/modules/operator/binop.py

@@ -189,8 +189,6 @@
     MM.register("!=", num_t, "complex128", OP.w_complex128_ne)
 
 # str ops
-MM.register("+",  "str", "str", OP.w_str_add)
-MM.register("*",  "str", "i32", OP.w_str_mul)
 MM.register("==", "str", "str", OP.w_str_eq)
 MM.register("!=", "str", "str", OP.w_str_ne)
 

spy/vm/modules/operator/opimpl_str.py

@@ -10,22 +10,6 @@
     from spy.vm.vm import SPyVM
 
 
-@OP.builtin_func
-def w_str_add(vm: "SPyVM", w_a: W_Str, w_b: W_Str) -> W_Str:
-    assert isinstance(w_a, W_Str)
-    assert isinstance(w_b, W_Str)
-    ptr_c = vm.ll.call("spy_str_add", w_a.ptr, w_b.ptr)
-    return W_Str.from_ptr(vm, ptr_c)
-
-
-@OP.builtin_func
-def w_str_mul(vm: "SPyVM", w_a: W_Str, w_b: W_I32) -> W_Str:
-    assert isinstance(w_a, W_Str)
-    assert isinstance(w_b, W_I32)
-    ptr_c = vm.ll.call("spy_str_mul", w_a.ptr, w_b.value)
-    return W_Str.from_ptr(vm, ptr_c)
-
-
 @OP.builtin_func
 def w_str_eq(vm: "SPyVM", w_a: W_Str, w_b: W_Str) -> W_Bool:
     assert isinstance(w_a, W_Str)

spy/vm/modules/unsafe/ptr.py

@@ -223,7 +223,7 @@ def __init__(
         if addr == 0:
             assert length == 0
         else:
-            assert length >= 1
+            assert length >= 0
         self.w_T = w_T
         self.addr = fixedint.Int32(addr)
         self.length = fixedint.Int32(length)