mt-lang 0.4.23 → 0.4.25

data/std/net.mt

@@ -193,8 +193,8 @@ struct UdpReceiveState:
     released: bool
 
 
-function noop_waiter(frame: ptr[void]) -> void:
-    unsafe: frame
+function noop_waiter(_frame: ptr[void]) -> void:
+    pass
 
 
 function resolve_state(frame: ptr[void]) -> ptr[ResolveState]:
@@ -476,14 +476,14 @@ function tcp_socket_address_from_getsockname(handle: ptr[NativeTcpHandle]?) -> R
     var name_length = int<-size_of(NativeSocketStorage)
     let status_code = libuv_c.uv_tcp_getsockname(
             live_handle,
-            sockaddr_storage_as_sockaddr(unsafe: ptr_of(raw)),
+            sockaddr_storage_as_sockaddr(ptr_of(raw)),
             ptr_of(name_length)
         )
     if status_code != 0:
         return Result[SocketAddress, Error].failure(error= libuv_error(status_code))
 
     return socket_address_from_sockaddr(
-        sockaddr_storage_as_sockaddr(unsafe: ptr_of(raw)),
+        sockaddr_storage_as_sockaddr(ptr_of(raw)),
         ptr_uint<-name_length
     )
 
@@ -496,14 +496,14 @@ function tcp_socket_address_from_getpeername(handle: ptr[NativeTcpHandle]?) -> R
     var name_length = int<-size_of(NativeSocketStorage)
     let status_code = libuv_c.uv_tcp_getpeername(
             live_handle,
-            sockaddr_storage_as_sockaddr(unsafe: ptr_of(raw)),
+            sockaddr_storage_as_sockaddr(ptr_of(raw)),
             ptr_of(name_length)
         )
     if status_code != 0:
         return Result[SocketAddress, Error].failure(error= libuv_error(status_code))
 
     return socket_address_from_sockaddr(
-        sockaddr_storage_as_sockaddr(unsafe: ptr_of(raw)),
+        sockaddr_storage_as_sockaddr(ptr_of(raw)),
         ptr_uint<-name_length
     )
 
@@ -528,14 +528,14 @@ function udp_socket_address_from_getsockname(handle: ptr[NativeUdpHandle]?) -> R
     var name_length = int<-size_of(NativeSocketStorage)
     let status_code = libuv_c.uv_udp_getsockname(
             live_handle,
-            sockaddr_storage_as_sockaddr(unsafe: ptr_of(raw)),
+            sockaddr_storage_as_sockaddr(ptr_of(raw)),
             ptr_of(name_length)
         )
     if status_code != 0:
         return Result[SocketAddress, Error].failure(error= libuv_error(status_code))
 
     return socket_address_from_sockaddr(
-        sockaddr_storage_as_sockaddr(unsafe: ptr_of(raw)),
+        sockaddr_storage_as_sockaddr(ptr_of(raw)),
         ptr_uint<-name_length
     )
 
@@ -548,14 +548,14 @@ function udp_socket_address_from_getpeername(handle: ptr[NativeUdpHandle]?) -> R
     var name_length = int<-size_of(NativeSocketStorage)
     let status_code = libuv_c.uv_udp_getpeername(
             live_handle,
-            sockaddr_storage_as_sockaddr(unsafe: ptr_of(raw)),
+            sockaddr_storage_as_sockaddr(ptr_of(raw)),
             ptr_of(name_length)
         )
     if status_code != 0:
         return Result[SocketAddress, Error].failure(error= libuv_error(status_code))
 
     return socket_address_from_sockaddr(
-        sockaddr_storage_as_sockaddr(unsafe: ptr_of(raw)),
+        sockaddr_storage_as_sockaddr(ptr_of(raw)),
         ptr_uint<-name_length
     )
 
@@ -785,7 +785,7 @@ function finish_connect(state: ptr[ConnectState], result_value: Result[TcpStream
             notify = true
 
     if notify and waiter_frame != null[ptr[void]]:
-        waiter(unsafe: waiter_frame)
+        waiter(waiter_frame)
         return
 
     if unsafe: read(state).released:
@@ -805,7 +805,7 @@ function connect_callback(req: ptr[NativeConnectRequest], status_code: int) -> v
     if status_code != 0:
         let handle = unsafe: read(state).handle
         if handle != null[ptr[NativeTcpHandle]]:
-            close_tcp_handle(unsafe: handle)
+            close_tcp_handle(handle)
             unsafe: read(state).handle = null
 
         finish_connect(state, Result[TcpStream, Error].failure(error= libuv_error(status_code)), status_code)
@@ -861,7 +861,7 @@ function accept_release(frame: ptr[void]) -> void:
 
     let listener = unsafe: read(state).listener
     if listener != null[ptr[ListenerState]]:
-        let live_listener = unsafe: listener
+        let live_listener = listener
         if unsafe: read(live_listener).accept_state == state:
             unsafe: read(live_listener).accept_state = null
 
@@ -904,7 +904,7 @@ function finish_accept(state: ptr[AcceptState], result_value: Result[TcpStream,
             notify = true
 
     if notify and waiter_frame != null[ptr[void]]:
-        waiter(unsafe: waiter_frame)
+        waiter(waiter_frame)
 
 
 function listener_close_callback(handle: ptr[NativeHandle]) -> void:
@@ -917,7 +917,7 @@ function listener_close_callback(handle: ptr[NativeHandle]) -> void:
     if pending_accept != null[ptr[AcceptState]]:
         unsafe: read(listener).accept_state = null
         finish_accept(
-            unsafe: pending_accept,
+            pending_accept,
             Result[TcpStream, Error].failure(error= net_error("listener closed")),
             -1
         )
@@ -959,7 +959,7 @@ function listener_connection_callback(server: ptr[NativeStreamHandle], status_co
         if pending_accept != null[ptr[AcceptState]]:
             unsafe: read(listener).accept_state = null
             finish_accept(
-                unsafe: pending_accept,
+                pending_accept,
                 Result[TcpStream, Error].failure(error= libuv_error(status_code)),
                 status_code
             )
@@ -969,7 +969,7 @@ function listener_connection_callback(server: ptr[NativeStreamHandle], status_co
 
     if pending_accept != null[ptr[AcceptState]]:
         unsafe: read(listener).accept_state = null
-        perform_listener_accept(listener, unsafe: pending_accept)
+        perform_listener_accept(listener, pending_accept)
         return
 
     unsafe: read(listener).pending_connections += 1
@@ -977,15 +977,14 @@ function listener_connection_callback(server: ptr[NativeStreamHandle], status_co
 
 function accept_impl(handle: ptr[NativeTcpHandle]?) -> Task[Result[TcpStream, Error]]:
     let state = heap.must_alloc_zeroed[AcceptState](1)
-    unsafe:
-        read(state).ready = false
-        read(state).status_code = 0
-        read(state).result = Result[TcpStream, Error].success(value= zero[TcpStream])
-        read(state).result_owned = false
-        read(state).waiter_frame = null
-        read(state).waiter = noop_waiter
-        read(state).waiter_registered = false
-        read(state).listener = null
+    read(state).ready = false
+    read(state).status_code = 0
+    read(state).result = Result[TcpStream, Error].success(value= zero[TcpStream])
+    read(state).result_owned = false
+    read(state).waiter_frame = null
+    read(state).waiter = noop_waiter
+    read(state).waiter_registered = false
+    read(state).listener = null
 
     let live_handle = handle else:
         finish_accept(state, Result[TcpStream, Error].failure(error= net_error("listener is released")), -1)
@@ -1000,7 +999,7 @@ function accept_impl(handle: ptr[NativeTcpHandle]?) -> Task[Result[TcpStream, Er
         return accept_task(state)
 
     let listener = unsafe: ptr[ListenerState]<-state_raw
-    unsafe: read(state).listener = listener
+    read(state).listener = listener
 
     let pending_error_code = unsafe: read(listener).pending_error_code
     if pending_error_code != 0:
@@ -1015,7 +1014,7 @@ function accept_impl(handle: ptr[NativeTcpHandle]?) -> Task[Result[TcpStream, Er
         return accept_task(state)
 
     if unsafe: read(listener).accept_state != null[ptr[AcceptState]]:
-        unsafe: read(state).listener = null
+        read(state).listener = null
         finish_accept(
             state,
             Result[TcpStream, Error].failure(error= net_error("listener already has a pending accept")),
@@ -1044,7 +1043,7 @@ function tcp_stream_close_callback(handle: ptr[NativeHandle]) -> void:
             read(stream).read_state = null
             read(pending_read).stream = null
         finish_stream_read(
-            unsafe: pending_read,
+            pending_read,
             Result[bytes.Bytes, Error].failure(error= net_error("tcp stream closed")),
             -1
         )
@@ -1059,8 +1058,7 @@ function close_tcp_stream_handle(handle: ptr[NativeTcpHandle]) -> void:
     if libuv.is_closing(tcp_as_handle(handle)) != 0:
         return
 
-    let state_raw = libuv.handle_get_data(tcp_as_handle(handle))
-    if state_raw == null[ptr[void]]:
+    let _ = libuv.handle_get_data(tcp_as_handle(handle)) else:
         close_tcp_handle(handle)
         return
 
@@ -1157,7 +1155,7 @@ function finish_write(
             notify = true
 
     if notify and waiter_frame != null[ptr[void]]:
-        waiter(unsafe: waiter_frame)
+        waiter(waiter_frame)
         return
 
     if unsafe: read(state).released:
@@ -1192,18 +1190,17 @@ function write_callback(req: ptr[NativeWriteRequest], status_code: int) -> void:
 
 function write_on_impl(handle: ptr[NativeTcpHandle]?, content: span[ubyte]) -> Task[Result[ptr_uint, Error]]:
     let state = heap.must_alloc_zeroed[WriteState](1)
-    unsafe:
-        read(state).ready = false
-        read(state).status_code = 0
-        read(state).result = Result[ptr_uint, Error].success(value= 0)
-        read(state).result_owned = false
-        read(state).waiter_frame = null
-        read(state).waiter = noop_waiter
-        read(state).waiter_registered = false
-        read(state).req = null
-        read(state).buffers = null
-        read(state).data = bytes.Bytes.empty()
-        read(state).released = false
+    read(state).ready = false
+    read(state).status_code = 0
+    read(state).result = Result[ptr_uint, Error].success(value= 0)
+    read(state).result_owned = false
+    read(state).waiter_frame = null
+    read(state).waiter = noop_waiter
+    read(state).waiter_registered = false
+    read(state).req = null
+    read(state).buffers = null
+    read(state).data = bytes.Bytes.empty()
+    read(state).released = false
 
     let live_handle = handle else:
         finish_write(state, Result[ptr_uint, Error].failure(error= net_error("tcp stream is released")), -1, true)
@@ -1334,7 +1331,7 @@ function stream_read_release(frame: ptr[void]) -> void:
 
     let stream = unsafe: read(state).stream
     if stream != null[ptr[TcpStreamState]]:
-        let live_stream = unsafe: stream
+        let live_stream = stream
         let handle = unsafe: read(live_stream).handle
         unsafe:
             if read(live_stream).read_state == state:
@@ -1342,7 +1339,7 @@ function stream_read_release(frame: ptr[void]) -> void:
             read(state).stream = null
 
         if handle != null[ptr[NativeTcpHandle]]:
-            libuv.read_stop(tcp_as_stream(unsafe: handle))
+            libuv.read_stop(tcp_as_stream(handle))
 
     finish_stream_read(state, Result[bytes.Bytes, Error].failure(error= net_error("tcp read released")), -1)
 
@@ -1381,7 +1378,7 @@ function finish_stream_read(state: ptr[ReadState], result_value: Result[bytes.By
             notify = true
 
     if notify and waiter_frame != null[ptr[void]]:
-        waiter(unsafe: waiter_frame)
+        waiter(waiter_frame)
         return
 
     if unsafe: read(state).released:
@@ -1399,13 +1396,12 @@ function stream_read_alloc_callback(
         return
 
     let stream = unsafe: ptr[TcpStreamState]<-state_raw
-    let pending_read = unsafe: read(stream).read_state
-    if pending_read == null[ptr[ReadState]]:
+    let pending_read = unsafe: read(stream).read_state else:
         let storage = unsafe: ptr[char]<-heap.must_alloc_zeroed_bytes(1, 1)
         unsafe: read(buf) = libuv.buf_init(storage, 0)
         return
 
-    let state = unsafe: pending_read
+    let state = pending_read
     var capacity = suggested_size
     let remaining = unsafe: read(state).max_bytes - read(state).received_bytes
     if remaining < capacity:
@@ -1430,12 +1426,11 @@ function stream_read_callback(
         return
 
     let stream = unsafe: ptr[TcpStreamState]<-state_raw
-    let pending_read = unsafe: read(stream).read_state
-    if pending_read == null[ptr[ReadState]]:
+    let pending_read = unsafe: read(stream).read_state else:
         release_uv_buffer(raw_buffer)
         return
 
-    let state = unsafe: pending_read
+    let state = pending_read
     if nread == 0:
         release_uv_buffer(raw_buffer)
         return
@@ -1494,20 +1489,19 @@ function stream_read_callback(
 
 function read_impl(handle: ptr[NativeTcpHandle]?, max_bytes: ptr_uint, exact: bool) -> Task[Result[bytes.Bytes, Error]]:
     let state = heap.must_alloc_zeroed[ReadState](1)
-    unsafe:
-        read(state).ready = false
-        read(state).status_code = 0
-        read(state).result = Result[bytes.Bytes, Error].success(value= bytes.Bytes.empty())
-        read(state).result_owned = false
-        read(state).waiter_frame = null
-        read(state).waiter = noop_waiter
-        read(state).waiter_registered = false
-        read(state).stream = null
-        read(state).max_bytes = max_bytes
-        read(state).buffer = null
-        read(state).received_bytes = 0
-        read(state).exact = exact
-        read(state).released = false
+    read(state).ready = false
+    read(state).status_code = 0
+    read(state).result = Result[bytes.Bytes, Error].success(value= bytes.Bytes.empty())
+    read(state).result_owned = false
+    read(state).waiter_frame = null
+    read(state).waiter = noop_waiter
+    read(state).waiter_registered = false
+    read(state).stream = null
+    read(state).max_bytes = max_bytes
+    read(state).buffer = null
+    read(state).received_bytes = 0
+    read(state).exact = exact
+    read(state).released = false
 
     if max_bytes == 0:
         finish_stream_read(
@@ -1649,7 +1643,7 @@ function finish_shutdown(
             notify = true
 
     if notify and waiter_frame != null[ptr[void]]:
-        waiter(unsafe: waiter_frame)
+        waiter(waiter_frame)
         return
 
     if unsafe: read(state).released:
@@ -1675,16 +1669,15 @@ function shutdown_callback(req: ptr[NativeShutdownRequest], status_code: int) ->
 
 function shutdown_impl(handle: ptr[NativeTcpHandle]?) -> Task[Result[bool, Error]]:
     let state = heap.must_alloc_zeroed[ShutdownState](1)
-    unsafe:
-        read(state).ready = false
-        read(state).status_code = 0
-        read(state).result = Result[bool, Error].success(value= false)
-        read(state).result_owned = false
-        read(state).waiter_frame = null
-        read(state).waiter = noop_waiter
-        read(state).waiter_registered = false
-        read(state).req = null
-        read(state).released = false
+    read(state).ready = false
+    read(state).status_code = 0
+    read(state).result = Result[bool, Error].success(value= false)
+    read(state).result_owned = false
+    read(state).waiter_frame = null
+    read(state).waiter = noop_waiter
+    read(state).waiter_registered = false
+    read(state).req = null
+    read(state).released = false
 
     let live_handle = handle else:
         finish_shutdown(state, Result[bool, Error].failure(error= net_error("tcp stream is released")), -1, true)
@@ -1722,7 +1715,7 @@ function udp_socket_close_callback(handle: ptr[NativeHandle]) -> void:
             read(socket).receive_state = null
             read(pending_receive).socket = null
         finish_udp_receive(
-            unsafe: pending_receive,
+            pending_receive,
             Result[UdpDatagram, Error].failure(error= net_error("udp socket closed")),
             -1
         )
@@ -1737,8 +1730,7 @@ function close_udp_socket_handle(handle: ptr[NativeUdpHandle]) -> void:
     if libuv.is_closing(udp_as_handle(handle)) != 0:
         return
 
-    let state_raw = libuv.handle_get_data(udp_as_handle(handle))
-    if state_raw == null[ptr[void]]:
+    let _ = libuv.handle_get_data(udp_as_handle(handle)) else:
         close_raw_udp_handle(handle)
         return
 
@@ -1850,7 +1842,7 @@ function finish_udp_send(
                     close_udp_socket_handle(h)
 
     if notify and waiter_frame != null[ptr[void]]:
-        waiter(unsafe: waiter_frame)
+        waiter(waiter_frame)
         return
 
     if unsafe: read(state).released:
@@ -1895,21 +1887,20 @@ function udp_send_impl(
     use_destination: bool
 ) -> Task[Result[ptr_uint, Error]]:
     let state = heap.must_alloc_zeroed[UdpSendState](1)
-    unsafe:
-        read(state).ready = false
-        read(state).status_code = 0
-        read(state).result = Result[ptr_uint, Error].success(value= 0)
-        read(state).result_owned = false
-        read(state).waiter_frame = null
-        read(state).waiter = noop_waiter
-        read(state).waiter_registered = false
-        read(state).req = null
-        read(state).buffers = null
-        read(state).data = bytes.Bytes.empty()
-        read(state).destination = zero[SocketAddress]
-        read(state).destination_owned = false
-        read(state).released = false
-        read(state).socket = null
+    read(state).ready = false
+    read(state).status_code = 0
+    read(state).result = Result[ptr_uint, Error].success(value= 0)
+    read(state).result_owned = false
+    read(state).waiter_frame = null
+    read(state).waiter = noop_waiter
+    read(state).waiter_registered = false
+    read(state).req = null
+    read(state).buffers = null
+    read(state).data = bytes.Bytes.empty()
+    read(state).destination = zero[SocketAddress]
+    read(state).destination_owned = false
+    read(state).released = false
+    read(state).socket = null
 
     let live_handle = handle else:
         finish_udp_send(state, Result[ptr_uint, Error].failure(error= net_error("udp socket is released")), -1, true)
@@ -1930,9 +1921,8 @@ function udp_send_impl(
                 finish_udp_send(state, Result[ptr_uint, Error].failure(error= error), error.code, true)
                 return udp_send_task(state)
             Result.success as payload:
-                unsafe:
-                    read(state).destination = payload.value
-                    read(state).destination_owned = true
+                read(state).destination = payload.value
+                read(state).destination_owned = true
 
     let copied = bytes.Bytes.copy(content)
     let copied_data = copied.data else:
@@ -1941,7 +1931,7 @@ function udp_send_impl(
 
     var remote_address: const_ptr[NativeSockAddr]? = null[const_ptr[NativeSockAddr]]
     if use_destination:
-        let destination_storage = unsafe: read(state).destination.storage else:
+        let destination_storage = read(state).destination.storage else:
             var payload = copied
             payload.release()
             finish_udp_send(
@@ -1963,8 +1953,7 @@ function udp_send_impl(
         read(buffers) = libuv.buf_init(ptr[char]<-copied_data, uint<-copied.len)
         libuv.req_set_data(udp_send_req_as_base(req), ptr[void]<-state)
 
-    let socket_raw = libuv.handle_get_data(udp_as_handle(live_handle))
-    if socket_raw == null[ptr[void]]:
+    let socket_raw = libuv.handle_get_data(udp_as_handle(live_handle)) else:
         unsafe:
             heap.release_bytes(ptr[void]<-req)
             read(state).req = null
@@ -1977,7 +1966,12 @@ function udp_send_impl(
                 var target = read(state).destination
                 target.release()
                 read(state).destination_owned = false
-        finish_udp_send(state, Result[ptr_uint, Error].failure(error= net_error("udp socket state is missing")), -1, true)
+        finish_udp_send(
+            state,
+            Result[ptr_uint, Error].failure(error= net_error("udp socket state is missing")),
+            -1,
+            true
+        )
         return udp_send_task(state)
 
     let socket_state = unsafe: ptr[UdpSocketState]<-socket_raw
@@ -2083,7 +2077,7 @@ function udp_receive_release(frame: ptr[void]) -> void:
     if unsafe: read(state).ready:
         let socket = unsafe: read(state).socket
         if socket != null[ptr[UdpSocketState]]:
-            let live_socket = unsafe: socket
+            let live_socket = socket
             if unsafe: read(live_socket).receive_state == state:
                 unsafe: read(live_socket).receive_state = null
         udp_receive_cleanup_and_release(state)
@@ -2093,7 +2087,7 @@ function udp_receive_release(frame: ptr[void]) -> void:
 
     let socket = unsafe: read(state).socket
     if socket != null[ptr[UdpSocketState]]:
-        let live_socket = unsafe: socket
+        let live_socket = socket
         let handle = unsafe: read(live_socket).handle
         unsafe:
             if read(live_socket).receive_state == state:
@@ -2101,7 +2095,7 @@ function udp_receive_release(frame: ptr[void]) -> void:
             read(state).socket = null
 
         if handle != null[ptr[NativeUdpHandle]]:
-            libuv.udp_recv_stop(unsafe: handle)
+            libuv.udp_recv_stop(handle)
 
     finish_udp_receive(state, Result[UdpDatagram, Error].failure(error= net_error("udp receive released")), -1)
 
@@ -2144,7 +2138,7 @@ function finish_udp_receive(
             notify = true
 
     if notify and waiter_frame != null[ptr[void]]:
-        waiter(unsafe: waiter_frame)
+        waiter(waiter_frame)
         return
 
     if unsafe: read(state).released:
@@ -2162,13 +2156,12 @@ function udp_receive_alloc_callback(
         return
 
     let socket = unsafe: ptr[UdpSocketState]<-state_raw
-    let pending_receive = unsafe: read(socket).receive_state
-    if pending_receive == null[ptr[UdpReceiveState]]:
+    let pending_receive = unsafe: read(socket).receive_state else:
         let storage = unsafe: ptr[char]<-heap.must_alloc_zeroed_bytes(1, 1)
         unsafe: read(buf) = libuv.buf_init(storage, 0)
         return
 
-    let state = unsafe: pending_receive
+    let state = pending_receive
     var capacity = suggested_size
     let max_bytes = unsafe: read(state).max_bytes
     if max_bytes < capacity:
@@ -2195,12 +2188,11 @@ function udp_receive_callback(
         return
 
     let socket = unsafe: ptr[UdpSocketState]<-state_raw
-    let pending_receive = unsafe: read(socket).receive_state
-    if pending_receive == null[ptr[UdpReceiveState]]:
+    let pending_receive = unsafe: read(socket).receive_state else:
         release_uv_buffer(raw_buffer)
         return
 
-    let state = unsafe: pending_receive
+    let state = pending_receive
     if nread == 0:
         release_uv_buffer(raw_buffer)
         return
@@ -2242,17 +2234,16 @@ function udp_receive_callback(
 
 function recv_from_impl(handle: ptr[NativeUdpHandle]?, max_bytes: ptr_uint) -> Task[Result[UdpDatagram, Error]]:
     let state = heap.must_alloc_zeroed[UdpReceiveState](1)
-    unsafe:
-        read(state).ready = false
-        read(state).status_code = 0
-        read(state).result = Result[UdpDatagram, Error].success(value= zero[UdpDatagram])
-        read(state).result_owned = false
-        read(state).waiter_frame = null
-        read(state).waiter = noop_waiter
-        read(state).waiter_registered = false
-        read(state).socket = null
-        read(state).max_bytes = max_bytes
-        read(state).released = false
+    read(state).ready = false
+    read(state).status_code = 0
+    read(state).result = Result[UdpDatagram, Error].success(value= zero[UdpDatagram])
+    read(state).result_owned = false
+    read(state).waiter_frame = null
+    read(state).waiter = noop_waiter
+    read(state).waiter_registered = false
+    read(state).socket = null
+    read(state).max_bytes = max_bytes
+    read(state).released = false
 
     if max_bytes == 0:
         finish_udp_receive(
@@ -2350,7 +2341,7 @@ function finish_resolve(state: ptr[ResolveState], result_value: Result[SocketAdd
             notify = true
 
     if notify and waiter_frame != null[ptr[void]]:
-        waiter(unsafe: waiter_frame)
+        waiter(waiter_frame)
 
 
 function finish_resolve_all(
@@ -2374,7 +2365,7 @@ function finish_resolve_all(
             notify = true
 
     if notify and waiter_frame != null[ptr[void]]:
-        waiter(unsafe: waiter_frame)
+        waiter(waiter_frame)
 
 
 function resolve_callback(
@@ -2454,7 +2445,7 @@ function resolve_all_callback(
         if current == null:
             break
 
-        let live_current = unsafe: current
+        let live_current = current
         let ai = unsafe: read(live_current)
         let address_result = socket_address_from_sockaddr(ai.ai_addr, ptr_uint<-ai.ai_addrlen)
         match address_result:
@@ -2514,14 +2505,13 @@ function resolve_on_impl(runtime: aio.Runtime, node: str, service: str) -> Task[
         loop,
         req,
         resolve_callback,
-        unsafe: read(state).node,
-        unsafe: read(state).service,
+        read(state).node,
+        read(state).service,
         null[const_ptr[NativeAddrInfo]]
     )
     if queue_status != 0:
-        unsafe:
-            heap.release(req)
-            read(state).req = null
+        heap.release(req)
+        read(state).req = null
         finish_resolve(state, Result[SocketAddress, Error].failure(error= libuv_error(queue_status)), queue_status)
 
     return resolve_task(state)
@@ -2560,14 +2550,13 @@ function resolve_all_on_impl(
         loop,
         req,
         resolve_all_callback,
-        unsafe: read(state).node,
-        unsafe: read(state).service,
+        read(state).node,
+        read(state).service,
         null[const_ptr[NativeAddrInfo]]
     )
     if queue_status != 0:
-        unsafe:
-            heap.release(req)
-            read(state).req = null
+        heap.release(req)
+        read(state).req = null
         finish_resolve_all(
             state,
             Result[vec.Vec[SocketAddress], Error].failure(error= libuv_error(queue_status)),
@@ -2579,19 +2568,18 @@ function resolve_all_on_impl(
 
 function connect_on_impl(runtime: aio.Runtime, address: SocketAddress) -> Task[Result[TcpStream, Error]]:
     let state = heap.must_alloc_zeroed[ConnectState](1)
-    unsafe:
-        read(state).ready = false
-        read(state).status_code = 0
-        read(state).result = Result[TcpStream, Error].success(value= zero[TcpStream])
-        read(state).result_owned = false
-        read(state).waiter_frame = null
-        read(state).waiter = noop_waiter
-        read(state).waiter_registered = false
-        read(state).req = null
-        read(state).handle = null
-        read(state).destination = zero[SocketAddress]
-        read(state).destination_owned = false
-        read(state).released = false
+    read(state).ready = false
+    read(state).status_code = 0
+    read(state).result = Result[TcpStream, Error].success(value= zero[TcpStream])
+    read(state).result_owned = false
+    read(state).waiter_frame = null
+    read(state).waiter = noop_waiter
+    read(state).waiter_registered = false
+    read(state).req = null
+    read(state).handle = null
+    read(state).destination = zero[SocketAddress]
+    read(state).destination_owned = false
+    read(state).released = false
 
     match duplicate_socket_address(address):
         Result.failure as payload:
@@ -2599,9 +2587,8 @@ function connect_on_impl(runtime: aio.Runtime, address: SocketAddress) -> Task[R
             finish_connect(state, Result[TcpStream, Error].failure(error= error), error.code)
             return connect_task(state)
         Result.success as payload:
-            unsafe:
-                read(state).destination = payload.value
-                read(state).destination_owned = true
+            read(state).destination = payload.value
+            read(state).destination_owned = true
 
     let handle = alloc_tcp_handle()
     let init_status = libuv.tcp_init(aio_backend.runtime_loop(runtime), handle)
@@ -2616,7 +2603,7 @@ function connect_on_impl(runtime: aio.Runtime, address: SocketAddress) -> Task[R
         read(state).handle = handle
         libuv.req_set_data(connect_req_as_base(req), ptr[void]<-state)
 
-    let destination_storage = unsafe: read(state).destination.storage else:
+    let destination_storage = read(state).destination.storage else:
         unsafe:
             heap.release_bytes(ptr[void]<-req)
             read(state).req = null
@@ -2723,7 +2710,7 @@ extending SocketAddress:
                 error = invalid_address_error("socket address is released")
             )
 
-        let ss_ptr = unsafe: storage
+        let ss_ptr = storage
         let family = (unsafe: read(ss_ptr)).ss_family
 
         let v4_family = ipv4_socket_family()
@@ -2800,7 +2787,7 @@ extending TcpListener:
             if pending_accept != null[ptr[AcceptState]]:
                 unsafe: read(listener).accept_state = null
                 finish_accept(
-                    unsafe: pending_accept,
+                    pending_accept,
                     Result[TcpStream, Error].failure(error= net_error("listener released")),
                     -1
                 )
@@ -2823,8 +2810,7 @@ extending UdpSocket:
         let handle = this.handle else:
             return
 
-        let state_raw = libuv.handle_get_data(udp_as_handle(handle))
-        if state_raw == null[ptr[void]]:
+        let state_raw = libuv.handle_get_data(udp_as_handle(handle)) else:
             this.handle = null
             close_raw_udp_handle(handle)
             return