Upgrade to Mojo 2024.7.1305

Author: f0cii

.gitignore

@@ -170,3 +170,4 @@ cython_debug/
 libmoxt.so
 .env
 config.toml
+*.Identifier

base/c.mojo

@@ -35,7 +35,7 @@ alias c_void_pointer = UnsafePointer[c_void]
 
 
 alias any_pointer_simd_int8_to_pointer_simd_int8 = rebind[
-    Pointer[SIMD[DType.int8, 1]], UnsafePointer[SIMD[DType.int8, 1]]
+    UnsafePointer[SIMD[DType.int8, 1]], UnsafePointer[SIMD[DType.int8, 1]]
 ]
 
 
@@ -144,15 +144,15 @@ fn c_str_to_string_raw(s: UnsafePointer[UInt8], n: Int) -> String:
 
 fn c_str_to_string(s: UnsafePointer[c_schar], n: Int) -> String:
     var size = n + 1
-    var ptr = Pointer[Int8]().alloc(size)
+    var ptr = UnsafePointer[Int8]().alloc(size)
     memset_zero(ptr.offset(n), 1)
     memcpy(ptr, s, n)
     return String(ptr.bitcast[UInt8](), size)
 
 
 fn c_str_to_string(s: UnsafePointer[c_char], n: Int) -> String:
     var size = n + 1
-    var ptr = Pointer[UInt8]().alloc(size)
+    var ptr = UnsafePointer[UInt8]().alloc(size)
     memset_zero(ptr.offset(n), 1)
     memcpy(ptr, s, n)
     return String(ptr, size)

base/far.mojo

@@ -41,7 +41,7 @@ struct Far:
             self.ptr,
             unsafe_ptr_as_scalar_pointer(key.unsafe_ptr()),
             len(key),
-            Pointer[c_size_t].address_of(n),
+            UnsafePointer[c_size_t].address_of(n),
         )
         return c_str_to_string(c_str, n)
 

base/fixed.mojo

@@ -65,11 +65,8 @@ struct Fixed(Stringable):
             _value: FIXED_SCALE_I * v,
         }
 
-    fn __init__(v: FloatLiteral) -> Self:
-        return Self {_value: Int64(FIXED_SCALE_F * v)}
-
     fn __init__(v: Float64) -> Self:
-        return Self {_value: Int64(FIXED_SCALE_F * v)}
+        return Self {_value: Int64(int(v * FIXED_SCALE_F))}
 
     fn __init__(v: String) -> Self:
         var v_ = seq_fixed12_new_string(

base/globals.mojo

@@ -57,48 +57,48 @@ fn _destroy_global(p: UnsafePointer[NoneType]):
     p.free()
 
 
-fn _GLOBAL_INT[name: StringLiteral]() -> Pointer[Int]:
+fn _GLOBAL_INT[name: StringLiteral]() -> UnsafePointer[Int]:
     var p = _get_global[name, _initialize_int, _destroy_int]()
     return p.bitcast[Int]()
 
 
-fn _initialize_int(payload: Pointer[NoneType]) -> Pointer[NoneType]:
-    var data = Pointer[Int].alloc(1)
+fn _initialize_int(payload: UnsafePointer[NoneType]) -> UnsafePointer[NoneType]:
+    var data = UnsafePointer[Int].alloc(1)
     data[0] = 0
     return data.bitcast[NoneType]()
 
 
-fn _destroy_int(p: Pointer[NoneType]):
+fn _destroy_int(p: UnsafePointer[NoneType]):
     p.free()
 
 
-fn _GLOBAL_FLOAT[name: StringLiteral]() -> Pointer[Float64]:
+fn _GLOBAL_FLOAT[name: StringLiteral]() -> UnsafePointer[Float64]:
     var p = _get_global[name, _initialize_float64, _destroy_float64]()
     return p.bitcast[Float64]()
 
 
-fn _initialize_float64(payload: Pointer[NoneType]) -> Pointer[NoneType]:
-    var data = Pointer[Float64].alloc(1)
-    data.store(0)
+fn _initialize_float64(payload: UnsafePointer[NoneType]) -> UnsafePointer[NoneType]:
+    var data = UnsafePointer[Float64].alloc(1)
+    data[0] = 0
     return data.bitcast[NoneType]()
 
 
-fn _destroy_float64(p: Pointer[NoneType]):
+fn _destroy_float64(p: UnsafePointer[NoneType]):
     p.free()
 
 
-fn _GLOBAL_BOOL[name: StringLiteral]() -> Pointer[Bool]:
+fn _GLOBAL_BOOL[name: StringLiteral]() -> UnsafePointer[Bool]:
     var p = _get_global[name, _initialize_bool, _destroy_bool]()
     return p.bitcast[Bool]()
 
 
-fn _initialize_bool(payload: Pointer[NoneType]) -> Pointer[NoneType]:
-    var data = Pointer[Bool].alloc(1)
-    data.store(False)
+fn _initialize_bool(payload: UnsafePointer[NoneType]) -> UnsafePointer[NoneType]:
+    var data = UnsafePointer[Bool].alloc(1)
+    data[0] = False
     return data.bitcast[NoneType]()
 
 
-fn _destroy_bool(p: Pointer[NoneType]):
+fn _destroy_bool(p: UnsafePointer[NoneType]):
     p.free()
 
 

base/mo.mojo

@@ -41,8 +41,8 @@ fn seq_set_global_string(id: Int, s: String) -> None:
 fn seq_get_global_string(id: Int) -> String:
     var s_len: c_size_t = 0
     var s = external_call[
-        "seq_get_global_string", c_char_pointer, Int, Pointer[c_size_t]
-    ](id, Pointer.address_of(s_len))
+        "seq_get_global_string", c_char_pointer, Int, UnsafePointer[c_size_t]
+    ](id, UnsafePointer.address_of(s_len))
     return c_str_to_string(s, s_len)
 
 
@@ -227,47 +227,47 @@ fn seq_simdjson_ondemand_get_string_d(
     p: c_void_pointer,
     key: c_char_pointer,
     len: c_size_t,
-    n: Pointer[c_size_t],
+    n: UnsafePointer[c_size_t],
 ) -> c_char_pointer:
     return external_call[
         "seq_simdjson_ondemand_get_string_d",
         c_char_pointer,
         c_void_pointer,
         c_char_pointer,
         c_size_t,
-        Pointer[c_size_t],
+        UnsafePointer[c_size_t],
     ](p, key, len, n)
 
 
 fn seq_simdjson_ondemand_get_string_v(
     p: c_void_pointer,
     key: c_char_pointer,
     len: c_size_t,
-    n: Pointer[c_size_t],
+    n: UnsafePointer[c_size_t],
 ) -> c_char_pointer:
     return external_call[
         "seq_simdjson_ondemand_get_string_v",
         c_char_pointer,
         c_void_pointer,
         c_char_pointer,
         c_size_t,
-        Pointer[c_size_t],
+        UnsafePointer[c_size_t],
     ](p, key, len, n)
 
 
 fn seq_simdjson_ondemand_get_string_o(
     p: c_void_pointer,
     key: c_char_pointer,
     len: c_size_t,
-    n: Pointer[c_size_t],
+    n: UnsafePointer[c_size_t],
 ) -> c_char_pointer:
     return external_call[
         "seq_simdjson_ondemand_get_string_o",
         c_char_pointer,
         c_void_pointer,
         c_char_pointer,
         c_size_t,
-        Pointer[c_size_t],
+        UnsafePointer[c_size_t],
     ](p, key, len, n)
 
 
@@ -400,13 +400,13 @@ fn seq_simdjson_ondemand_bool_v(p: c_void_pointer) -> Bool:
 # const char *
 # seq_simdjson_ondemand_string_v(ondemand ::value *p, size_t *n)
 fn seq_simdjson_ondemand_string_v(
-    p: c_void_pointer, n: Pointer[c_size_t]
+    p: c_void_pointer, n: UnsafePointer[c_size_t]
 ) -> c_char_pointer:
     return external_call[
         "seq_simdjson_ondemand_string_v",
         c_char_pointer,
         c_void_pointer,
-        Pointer[c_size_t],
+        UnsafePointer[c_size_t],
     ](p, n)
 
 
@@ -739,14 +739,14 @@ fn seq_simdjson_ondemand_array_at_bool(
 #                                                         size_t index,
 #                                                         size_t *n);
 fn seq_simdjson_ondemand_array_at_str(
-    p: c_void_pointer, index: c_size_t, n: Pointer[c_size_t]
+    p: c_void_pointer, index: c_size_t, n: UnsafePointer[c_size_t]
 ) -> c_char_pointer:
     return external_call[
         "seq_simdjson_ondemand_array_at_str",
         c_char_pointer,
         c_void_pointer,
         c_size_t,
-        Pointer[c_size_t],
+        UnsafePointer[c_size_t],
     ](p, index, n)
 
 
@@ -806,13 +806,13 @@ fn seq_simdjson_ondemand_array_iter_get_bool(p: c_void_pointer) -> Bool:
 # const char *seq_simdjson_ondemand_array_iter_get_str(
 #     ondemand::array_iterator *self, size_t *n);
 fn seq_simdjson_ondemand_array_iter_get_str(
-    p: c_void_pointer, n: Pointer[c_size_t]
+    p: c_void_pointer, n: UnsafePointer[c_size_t]
 ) -> c_char_pointer:
     return external_call[
         "seq_simdjson_ondemand_array_iter_get_str",
         c_char_pointer,
         c_void_pointer,
-        Pointer[c_size_t],
+        UnsafePointer[c_size_t],
     ](p, n)
 
 
@@ -877,15 +877,15 @@ fn seq_simdjson_ondemand_array_iter_not_equal(
 # SEQ_FUNC void
 # seq_simdjson_ondemand_array_iter_step(ondemand::array_iterator *self);
 fn seq_simdjson_ondemand_array_iter_step(it: c_void_pointer) -> None:
-    return external_call[
+    external_call[
         "seq_simdjson_ondemand_array_iter_step", NoneType, c_void_pointer
     ](it)
 
 
 # SEQ_FUNC void
 # seq_simdjson_ondemand_array_iter_free(ondemand::array_iterator *p)
 fn seq_simdjson_ondemand_array_iter_free(it: c_void_pointer) -> None:
-    return external_call[
+    external_call[
         "seq_simdjson_ondemand_array_iter_free",
         NoneType,
         c_void_pointer,
@@ -1120,15 +1120,15 @@ fn seq_far_get_string(
     p: c_void_pointer,
     key: c_char_pointer,
     key_len: c_size_t,
-    n: Pointer[c_size_t],
+    n: UnsafePointer[c_size_t],
 ) -> c_char_pointer:
     return external_call[
         "seq_far_get_string",
         c_char_pointer,
         c_void_pointer,
         c_char_pointer,
         c_size_t,
-        Pointer[c_size_t],
+        UnsafePointer[c_size_t],
     ](p, key, key_len, n)
 
 
@@ -1286,14 +1286,14 @@ fn seq_ssmap_set(
 # SEQ_FUNC const char *seq_ssmap_get(std::map<std::string, std::string> *p,
 #                                    const char *name, size_t *n)
 fn seq_ssmap_get(
-    p: c_void_pointer, name: c_char_pointer, n: Pointer[c_size_t]
+    p: c_void_pointer, name: c_char_pointer, n: UnsafePointer[c_size_t]
 ) -> c_char_pointer:
     return external_call[
         "seq_ssmap_get",
         c_char_pointer,
         c_void_pointer,
         c_char_pointer,
-        Pointer[c_size_t],
+        UnsafePointer[c_size_t],
     ](p, name, n)
 
 
@@ -1397,15 +1397,15 @@ fn seq_strtod(s: c_char_pointer, s_len: c_size_t) -> Float64:
 
 
 fn test_identity_pool() -> None:
-    return external_call["test_identity_pool", NoneType]()
+    external_call["test_identity_pool", NoneType]()
 
 
 fn seq_test_spdlog() -> None:
-    return external_call["seq_test_spdlog", NoneType]()
+    external_call["seq_test_spdlog", NoneType]()
 
 
 fn test_ondemand_parser_pool() -> None:
-    return external_call["test_ondemand_parser_pool", NoneType]()
+    external_call["test_ondemand_parser_pool", NoneType]()
 
 
 fn seq_add(a: Int, b: Int) -> Int:
@@ -1426,14 +1426,12 @@ alias signal_handle_t = fn (c_int) raises -> None
 
 # SEQ_FUNC void seq_init_signal(signal_handle_t handle);
 fn seq_init_signal(callback: signal_handle_t) -> None:
-    return external_call["seq_init_signal", NoneType, signal_handle_t](callback)
+    external_call["seq_init_signal", NoneType, signal_handle_t](callback)
 
 
 # SEQ_FUNC void seq_init_photon_signal(signal_handle_t handle);
 fn seq_init_photon_signal(callback: signal_handle_t) -> None:
-    return external_call["seq_init_photon_signal", NoneType, signal_handle_t](
-        callback
-    )
+    external_call["seq_init_photon_signal", NoneType, signal_handle_t](callback)
 
 
 fn seq_skiplist_new(is_forward: Bool) -> c_void_pointer:
@@ -1465,7 +1463,7 @@ fn seq_skiplist_search(list: c_void_pointer, key: Int64) -> Int64:
 
 
 fn seq_skiplist_dump(list: c_void_pointer) -> None:
-    return external_call["seq_skiplist_dump", NoneType, c_void_pointer](list)
+    external_call["seq_skiplist_dump", NoneType, c_void_pointer](list)
 
 
 fn seq_skiplist_begin(list: c_void_pointer) -> c_void_pointer:
@@ -1489,14 +1487,14 @@ fn seq_skiplist_next(
 
 
 fn seq_skiplist_node_value(
-    node: c_void_pointer, key: Pointer[Int64], value: Pointer[Int64]
+    node: c_void_pointer, key: UnsafePointer[Int64], value: UnsafePointer[Int64]
 ) -> None:
     external_call[
         "seq_skiplist_node_value",
         NoneType,
         c_void_pointer,
-        Pointer[Int64],
-        Pointer[Int64],
+        UnsafePointer[Int64],
+        UnsafePointer[Int64],
     ](node, key, value)
 
 

base/moutil.mojo

@@ -6,11 +6,11 @@ from ylstdlib.time import time_ns
 
 
 fn time_ms() -> Int64:
-    return time_ns() / 1e6
+    return Int64(int(time_ns() / 1e6))
 
 
 fn time_us() -> Int64:
-    return time_ns() / 1e3
+    return Int64(int(time_ns() / 1e3))
 
 
 fn set_global_value_ptr[V: Intable](id: Int, v: UnsafePointer[V]) -> Int: