mt-lang 0.4.24 → 0.4.25

data/std/http.mt

@@ -530,12 +530,10 @@ function discard_buffer_prefix(buffer: ref[vec.Vec[ubyte]], count: ptr_uint) ->
         fatal(c"http.discard_buffer_prefix missing storage")
 
     let remaining = buffer.len - count
-    unsafe:
-        let data_ptr = data
-        var index: ptr_uint = 0
-        while index < remaining:
-            read(data_ptr + index) = read(data_ptr + count + index)
-            index += 1
+    var index: ptr_uint = 0
+    while index < remaining:
+        read(data + index) = read(data + count + index)
+        index += 1
 
     buffer.len = remaining
 
@@ -572,14 +570,14 @@ function parse_response_head(header_text: str) -> Result[ResponseHead, Error]:
         Option.some as payload:
             status_code = int<-payload.value
 
+    if first_space + 4 < status_line.len and status_line.byte_at(first_space + 4) != 32:
+        return Result[
+            ResponseHead,
+            Error
+        ].failure(error = response_error("status line must separate code and reason with a space"))
+
     var reason = string.String.create()
     if first_space + 4 < status_line.len:
-        if status_line.byte_at(first_space + 4) != 32:
-            return Result[
-                ResponseHead,
-                Error
-            ].failure(error = response_error("status line must separate code and reason with a space"))
-
         let reason_start = first_space + 5
         reason = string.String.from_str(status_line.slice(reason_start, status_line.len - reason_start))
 
@@ -641,10 +639,7 @@ function parse_response_head(header_text: str) -> Result[ResponseHead, Error]:
                 head.release()
                 return Result[ResponseHead, Error].failure(error = response_error("unsupported Transfer-Encoding"))
 
-        if next_line_end == header_text.len:
-            index = header_text.len
-        else:
-            index = next_line_end + 2
+        if next_line_end == header_text.len: index = header_text.len else: index = next_line_end + 2
 
     if head.chunked:
         head.content_length = Option[ptr_uint].none
@@ -844,7 +839,9 @@ async function read_chunked_body(stream: net.TcpStream, prefix: span[ubyte]) ->
                                         return Result[
                                             bytes.Bytes,
                                             Error
-                                        ].failure(error = response_error("chunked response ended before trailers were complete"))
+                                        ].failure(error = response_error(
+                                            "chunked response ended before trailers were complete"
+                                        ))
 
                                     buffer.append_span(chunk.as_span())
                                     chunk.release()

data/std/jobs.mt

@@ -46,8 +46,8 @@ function error_from_mailbox(source: aio_mailbox.Error) -> Error:
     return Error(code = source.code, message = source.message)
 
 
-function noop_completion(arg: ptr[void]) -> void:
-    unsafe: arg
+function noop_completion(_arg: ptr[void]) -> void:
+    pass
 
 
 function stop_pool_state(state: ptr[PoolState]) -> void:
@@ -163,14 +163,13 @@ public function create_on(runtime: aio.Runtime, worker_count: ptr_uint) -> Resul
                             return Result[Pool, Error].failure(error = error_from_mailbox(payload.error))
                         Result.success as mailbox_payload:
                             let state = heap.must_alloc_zeroed[PoolState](1)
-                            unsafe:
-                                state.mutex = mutex_payload.value
-                                state.condition = condition_payload.value
-                                state.queue = deque.Deque[WorkItem].create()
-                                state.queued_jobs = 0
-                                state.running_jobs = 0
-                                state.stopping = false
-                                state.completions = mailbox_payload.value
+                            state.mutex = mutex_payload.value
+                            state.condition = condition_payload.value
+                            state.queue = deque.Deque[WorkItem].create()
+                            state.queued_jobs = 0
+                            state.running_jobs = 0
+                            state.stopping = false
+                            state.completions = mailbox_payload.value
 
                             var workers = vec.Vec[thread.Thread].with_capacity(worker_count)
                             var index: ptr_uint = 0

data/std/json.mt

@@ -112,15 +112,13 @@ public function object_value(value: ptr[Object]?) -> Value:
 
 public function create_array_value() -> Value:
     let array_ptr = heap.must_alloc[Array](1)
-    unsafe:
-        read(array_ptr) = Array.create()
+    read(array_ptr) = Array.create()
     return array_value(array_ptr)
 
 
 public function create_object_value() -> Value:
     let object_ptr = heap.must_alloc[Object](1)
-    unsafe:
-        read(object_ptr) = Object.create()
+    read(object_ptr) = Object.create()
     return object_value(object_ptr)
 
 
@@ -178,33 +176,28 @@ function value_as_object(value: Value) -> ptr[Object]?:
 
 function convert_raw_array(item: ptr[cjson.JSON]) -> Result[Value, Error]:
     let array_ptr = heap.must_alloc[Array](1)
-    unsafe:
-        read(array_ptr) = Array.create()
+    read(array_ptr) = Array.create()
 
     let count = cjson.get_array_size(item)
     if count < 0:
-        unsafe:
-            read(array_ptr).release()
+        read(array_ptr).release()
         heap.release(array_ptr)
         return Result[Value, Error].failure(error = error_message("json array size failed"))
 
     var index: int = 0
     while index < count:
         let child = cjson.get_array_item(item, index) else:
-            unsafe:
-                read(array_ptr).release()
+            read(array_ptr).release()
             heap.release(array_ptr)
             return Result[Value, Error].failure(error = error_message("json array item missing"))
 
         match convert_raw_value(child):
             Result.failure as payload:
-                unsafe:
-                    read(array_ptr).release()
+                read(array_ptr).release()
                 heap.release(array_ptr)
                 return Result[Value, Error].failure(error = payload.error)
             Result.success as payload:
-                unsafe:
-                    read(array_ptr).values.push(payload.value)
+                read(array_ptr).values.push(payload.value)
 
         index += 1
 
@@ -213,30 +206,26 @@ function convert_raw_array(item: ptr[cjson.JSON]) -> Result[Value, Error]:
 
 function convert_raw_object(item: ptr[cjson.JSON]) -> Result[Value, Error]:
     let object_ptr = heap.must_alloc[Object](1)
-    unsafe:
-        read(object_ptr) = Object.create()
+    read(object_ptr) = Object.create()
 
     var child = unsafe: ptr[cjson.JSON]?<-read(item).child
     while child != null:
-        let current = unsafe: child
+        let current = child
         let key_ptr = unsafe: ptr[char]?<-read(current).string else:
-            unsafe:
-                read(object_ptr).release()
+            read(object_ptr).release()
             heap.release(object_ptr)
             return Result[Value, Error].failure(error = error_message("json object key missing"))
 
         match convert_raw_value(current):
             Result.failure as payload:
-                unsafe:
-                    read(object_ptr).release()
+                read(object_ptr).release()
                 heap.release(object_ptr)
                 return Result[Value, Error].failure(error = payload.error)
             Result.success as payload:
-                unsafe:
-                    read(object_ptr).entries.push(Entry(
-                        key = string.String.from_str(text.chars_as_str(key_ptr)),
-                        value = payload.value
-                    ))
+                read(object_ptr).entries.push(Entry(
+                    key = string.String.from_str(text.chars_as_str(key_ptr)),
+                    value = payload.value
+                ))
 
         child = unsafe: ptr[cjson.JSON]?<-read(current).next
 
@@ -380,7 +369,7 @@ function render_with_mode(value: Value, pretty: bool) -> Result[string.String, E
     if pretty:
         let rendered_ptr = cjson.print(raw_value) else:
             return Result[string.String, Error].failure(error = error_message("json print failed"))
-        defer: raw.cJSON_free(unsafe: rendered_ptr)
+        defer: raw.cJSON_free(rendered_ptr)
         return Result[
             string.String,
             Error
@@ -388,7 +377,7 @@ function render_with_mode(value: Value, pretty: bool) -> Result[string.String, E
 
     let rendered_ptr = cjson.print_unformatted(raw_value) else:
         return Result[string.String, Error].failure(error = error_message("json print failed"))
-    defer: raw.cJSON_free(unsafe: rendered_ptr)
+    defer: raw.cJSON_free(rendered_ptr)
     return Result[string.String, Error].success(value = string.String.from_str(text.chars_as_str(rendered_ptr)))
 
 

data/std/linked_map.mt

@@ -188,10 +188,7 @@ extending LinkedMap[K, V]:
             new_capacity = 8
 
         while new_capacity < min_capacity:
-            if new_capacity > heap.ptr_uint_max / 2:
-                new_capacity = min_capacity
-            else:
-                new_capacity *= 2
+            if new_capacity > heap.ptr_uint_max / 2: new_capacity = min_capacity else: new_capacity *= 2
 
         let new_buckets = heap.must_alloc_zeroed[ptr[Node[K, V]]?](new_capacity)
         let old_buckets = this.buckets
@@ -243,10 +240,7 @@ extending LinkedMap[K, V]:
             )
             read(bucket_ptr + index) = node
 
-            if tail == null:
-                this.head = node
-            else:
-                read(ptr[Node[K, V]]<-tail).order_next = node
+            if tail == null: this.head = node else: read(ptr[Node[K, V]]<-tail).order_next = node
             this.tail = node
 
         this.len += 1
@@ -267,7 +261,7 @@ extending LinkedMap[K, V]:
                     fatal(c"linked_map.LinkedMap.get_or_insert missing inserted value")
                 unsafe:
                     return ptr_of(read(ptr[Node[K, V]]<-current).value)
-            Option.some as ignored_payload:
+            Option.some:
                 fatal(c"linked_map.LinkedMap.get_or_insert replaced unexpectedly")
 
 

data/std/map.mt

@@ -181,10 +181,7 @@ extending Map[K, V]:
             new_capacity = 8
 
         while new_capacity < min_capacity:
-            if new_capacity > heap.ptr_uint_max / 2:
-                new_capacity = min_capacity
-            else:
-                new_capacity *= 2
+            if new_capacity > heap.ptr_uint_max / 2: new_capacity = min_capacity else: new_capacity *= 2
 
         let new_buckets = heap.must_alloc_zeroed[ptr[Node[K, V]]?](new_capacity)
         let old_buckets = this.buckets

data/std/net/channel.mt

@@ -418,7 +418,7 @@ extending HostMessage:
 
 extending Channel:
     public editable function release() -> void:
-        let protocol = unsafe: ptr_of(this.protocol)
+        let protocol = ptr_of(this.protocol)
         release_protocol_state(protocol)
         this.socket.release()
 
@@ -442,7 +442,7 @@ extending Channel:
                 message = string.String.from_str("udp channel payload exceeds configured maximum")
             ))
 
-        let protocol = unsafe: ptr_of(this.protocol)
+        let protocol = ptr_of(this.protocol)
         let sequence = allocate_sequence(protocol)
         (await send_connected_packet(this.socket, protocol, sequence, 0, content))?
         return Result[uint, net.Error].success(value = sequence)
@@ -455,7 +455,7 @@ extending Channel:
                 message = string.String.from_str("udp channel payload exceeds configured maximum")
             ))
 
-        let protocol = unsafe: ptr_of(this.protocol)
+        let protocol = ptr_of(this.protocol)
         let pending_len = unsafe: read(protocol).pending_reliable.len()
         if pending_len >= pending_window_limit(this.config):
             return Result[uint, net.Error].failure(error = net.Error(
@@ -478,7 +478,7 @@ extending Channel:
         defer: packet.release()
 
         let header = decode_header(packet)?
-        let protocol = unsafe: ptr_of(this.protocol)
+        let protocol = ptr_of(this.protocol)
         remove_acked_pending(protocol, header.ack, header.ack_bits)
         let is_new = mark_received(protocol, header.sequence)
         let is_reliable = (header.packet_flags & reliable_flag) != 0
@@ -499,7 +499,7 @@ extending Channel:
 
 
     public async editable function tick(frame: uint) -> Result[ptr_uint, net.Error]:
-        let protocol = unsafe: ptr_of(this.protocol)
+        let protocol = ptr_of(this.protocol)
         var resent: ptr_uint = 0
         var index: ptr_uint = 0
         while true:
@@ -537,7 +537,7 @@ extending Host:
             if removed.is_none():
                 break
             var peer = removed.unwrap()
-            let peer_ptr = unsafe: ptr_of(peer)
+            let peer_ptr = ptr_of(peer)
             release_peer_state(peer_ptr)
 
         this.peers.release()

data/std/net/lobby.mt

@@ -263,8 +263,7 @@ public async function discover_lobbies_on(
                 Result.success:
                     pass
 
-            let empty = bytes.Bytes.empty()
-            let _ = await conn.mux_send(lobby_channel, type_discover_request, empty.as_span(), mux.flag_reliable)
+            let _ = await conn.mux_send(lobby_channel, type_discover_request, zero[span[ubyte]], mux.flag_reliable)
 
             var frame: uint = 0
             var result = vec.Vec[LobbyInfo].create()
@@ -714,7 +713,8 @@ public function build_beacon_probe() -> bytes.Bytes:
 public function is_beacon_probe(data: span[ubyte]) -> bool:
     if data.len < beacon_probe_len:
         return false
-    return data[0] == beacon_magic[0] and data[1] == beacon_magic[1] and data[2] == beacon_magic[2] and data[3] == beacon_magic[3]
+    return data[0] == beacon_magic[0] and data[1] == beacon_magic[1] and
+        data[2] == beacon_magic[2] and data[3] == beacon_magic[3]
 
 
 public function build_beacon_response(info: ref[LobbyInfo]) -> bytes.Bytes:

data/std/net/manager.mt

@@ -5,7 +5,6 @@ import std.net as net
 import std.net.clock as clock
 import std.net.mux as mux
 import std.net.session as sess
-import std.string as string
 import std.vec as vec
 
 const channel_system: ubyte = 0

data/std/net/mux.mt

@@ -728,7 +728,7 @@ function assemble_fragment(
             let buf_data = heap.must_alloc[ubyte](full_size)
             var fill: ptr_uint = 0
             while fill < full_size:
-                unsafe: read(buf_data + fill) = 0
+                read(buf_data + fill) = 0
                 fill += 1
             buf = bytes.Bytes(data = buf_data, len = full_size)
         buffers.push(FragBuffer(

data/std/net/packet.mt

@@ -44,7 +44,10 @@ function decode_packet_length(header: bytes.Bytes) -> ptr_uint:
         fatal(c"packet frame header length mismatch")
 
     let header_span = header.as_span()
-    let length = ((uint<-header_span[0]) << 24) | ((uint<-header_span[1]) << 16) | ((uint<-header_span[2]) << 8) | (uint<-header_span[3])
+    let length = ((uint<-header_span[0]) << 24) |
+        ((uint<-header_span[1]) << 16) |
+        ((uint<-header_span[2]) << 8) |
+        (uint<-header_span[3])
     return length
 
 

data/std/net/punch.mt

@@ -72,7 +72,8 @@ public function build_punch_probe() -> bytes.Bytes:
 public function is_punch_probe(data: span[ubyte]) -> bool:
     if data.len < 4z:
         return false
-    return data[0] == punch_magic[0] and data[1] == punch_magic[1] and data[2] == punch_magic[2] and data[3] == punch_magic[3]
+    return data[0] == punch_magic[0] and data[1] == punch_magic[1] and
+        data[2] == punch_magic[2] and data[3] == punch_magic[3]
 
 
 function result_from_datagram(
@@ -125,7 +126,7 @@ public async function punch(
                 break
             let send_result = await socket.send_to(probe.as_span(), unsafe: read(cand_ptr).address)
             match send_result:
-                Result.failure as sp:
+                Result.failure:
                     return Result[PunchResult, Error].failure(
                         error = punch_error(err_send_failed, "burst send failed")
                     )

data/std/net/rpc.mt

@@ -47,9 +47,7 @@ public function parse_request_id(data: span[ubyte]) -> Result[uint, Error]:
 
 public function payload_after_header(data: span[ubyte]) -> span[ubyte]:
     if data.len <= header_bytes:
-        let empty = bytes.Bytes.empty()
-        let result = empty.as_span()
-        return result
+        return zero[span[ubyte]]
     unsafe:
         return span[ubyte](data = data.data + header_bytes, len = data.len - header_bytes)
 

data/std/net/session.mt

@@ -169,7 +169,10 @@ function generate_handshake_key() -> Result[ulong, net.Error]:
 
 function decode_uint_at(data: span[ubyte], offset: ptr_uint) -> uint:
     unsafe:
-        return uint<-read(data.data + offset) | (uint<-read(data.data + offset + 1) << 8) | (uint<-read(data.data + offset + 2) << 16) | (uint<-read(data.data + offset + 3) << 24)
+        return uint<-read(data.data + offset) |
+            (uint<-read(data.data + offset + 1) << 8) |
+            (uint<-read(data.data + offset + 2) << 16) |
+            (uint<-read(data.data + offset + 3) << 24)
 
 
 function channel_config_for(config: Config) -> chan.Config:
@@ -315,9 +318,7 @@ extending Connection:
                 defer: hb.release()
                 let send_result = await this.channel.send(hb.as_span())
                 match send_result:
-                    Result.failure:
-                        pass
-                    Result.success:
+                    Result.failure | Result.success:
                         pass
                 this.last_heartbeat_sent = frame
 
@@ -327,9 +328,7 @@ extending Connection:
 
         let channel_tick_result = await this.channel.tick(frame)
         match channel_tick_result:
-            Result.failure:
-                pass
-            Result.success:
+            Result.failure | Result.success:
                 pass
 
         await aio.sleep(1)
@@ -467,9 +466,7 @@ extending Connection:
         let send_result = await this.channel.send_reliable(d.as_span(), 0)
         this.state = ConnectionState.disconnected
         match send_result:
-            Result.failure:
-                return Result[bool, net.Error].success(value = true)
-            Result.success:
+            Result.failure | Result.success:
                 return Result[bool, net.Error].success(value = true)
 
 
@@ -657,9 +654,7 @@ extending Session:
                             defer: addr.release()
                             let send_result = await this.host.send(addr, hb.as_span())
                             match send_result:
-                                Result.failure:
-                                    pass
-                                Result.success:
+                                Result.failure | Result.success:
                                     pass
                         Result.failure:
                             pass
@@ -680,9 +675,7 @@ extending Session:
 
         let host_tick_result = await this.host.tick(frame)
         match host_tick_result:
-            Result.failure:
-                pass
-            Result.success:
+            Result.failure | Result.success:
                 pass
 
         await aio.sleep(1)
@@ -799,9 +792,7 @@ extending Session:
                 defer: d.release()
                 let send_result = await this.host.send_reliable(address, d.as_span(), 0)
                 match send_result:
-                    Result.failure:
-                        pass
-                    Result.success:
+                    Result.failure | Result.success:
                         pass
                 mark_peer_disconnected(ref_of(this), peer_id)
                 this.event_queue.push_back(PeerEvent(
@@ -1062,9 +1053,7 @@ async function drain_outgoing_session(session: ref[Session]) -> Result[bool, net
                         0
                     )
                     match send_result:
-                        Result.failure:
-                            pass
-                        Result.success:
+                        Result.failure | Result.success:
                             pass
                 else:
                     let send_result = await session.host.send(
@@ -1072,9 +1061,7 @@ async function drain_outgoing_session(session: ref[Session]) -> Result[bool, net
                         outgoing.payload.as_span()
                     )
                     match send_result:
-                        Result.failure:
-                            pass
-                        Result.success:
+                        Result.failure | Result.success:
                             pass
 
 

data/std/net/sync.mt

@@ -107,7 +107,7 @@ extending CompressedUshort:
 
 
     public function decode(encoded: ushort) -> float:
-        let ratio = float<-encoded / 65535.0
+        let ratio = encoded / 65535.0
         return this.min + ratio * (this.max - this.min)
 
 public struct CompressedUbyte:
@@ -127,7 +127,7 @@ extending CompressedUbyte:
 
 
     public function decode(encoded: ubyte) -> float:
-        let ratio = float<-encoded / 255.0
+        let ratio = encoded / 255.0
         return this.min + ratio * (this.max - this.min)
 
 public struct TickBuffer[T]:
@@ -138,7 +138,7 @@ public struct TickBuffer[T]:
 extending TickBuffer[T]:
     public editable function push(tick: uint, value: T) -> void:
         let offset: ptr_uint = ptr_uint<-(tick - this.base_tick)
-        while offset >= this.entries.len():
+        if offset >= this.entries.len():
             this.entries.push(value)
             return
         let ptr = this.entries.get(offset) else:

data/std/net/turn.mt

@@ -342,9 +342,11 @@ public function parse_data_indication(
     var attr_len: ptr_uint = read_ushort_be(data, 2z)
     var offset: ptr_uint = turn_header_len
     var found_peer: bool = false
-    var peer_addr: net.SocketAddress = zero[net.SocketAddress]
+    # Ownership is tracked manually here: both bindings are released on the
+    # failure path below and moved into TurnDatagram on success.
+    var peer_addr: net.SocketAddress = zero[net.SocketAddress]  # lint: ignore(owning-release-leak)
     var found_data: bool = false
-    var payload: bytes.Bytes = bytes.Bytes.empty()
+    var payload: bytes.Bytes = bytes.Bytes.empty()  # lint: ignore(owning-release-leak)
 
     while attr_len >= 4z:
         if offset + 4z > data.len:
@@ -387,6 +389,8 @@ public function parse_data_indication(
     if not found_peer or not found_data:
         if found_data:
             payload.release()
+        if found_peer:
+            peer_addr.release()
         return Result[TurnDatagram, Error].failure(
             error = turn_error(err_no_data_attribute, "data indication missing attributes")
         )
@@ -420,7 +424,7 @@ public async function send_data(
                     defer: packet.release()
                     let send_result = await socket.send_to(packet.as_span(), turn_server)
                     match send_result:
-                        Result.failure as sp:
+                        Result.failure:
                             return Result[ptr_uint, Error].failure(
                                 error = turn_error(err_send_failed, "send indication failed")
                             )