mt-lang 0.3.14 → 0.3.16

data/std/fs.windows.mt

@@ -89,7 +89,7 @@ function release_string_values(values: ref[vec.Vec[string.String]]) -> void:
 
 function path_kind(path: str) -> int:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
     return c.mt_fs_path_kind(storage.to_cstr(path))
 
 
@@ -170,7 +170,7 @@ public function is_directory(path: str) -> bool:
 
 public function read_text(path: str) -> Result[string.String, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_text = zero[c.mt_fs_string]
     var raw_error = zero[c.mt_fs_error]
@@ -187,7 +187,7 @@ public function read_lines(path: str) -> Result[Entries, Error]:
             return Result[Entries, Error].failure(error= payload.error)
         Result.success as payload:
             var content = payload.value
-            defer content.release()
+            defer: content.release()
 
             var values = vec.Vec[string.String].create()
             let content_text = content.as_str()
@@ -216,7 +216,7 @@ public function read_lines(path: str) -> Result[Entries, Error]:
 
 public function read_bytes(path: str) -> Result[bytes.Bytes, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_bytes = zero[c.mt_fs_string]
     var raw_error = zero[c.mt_fs_error]
@@ -229,7 +229,7 @@ public function read_bytes(path: str) -> Result[bytes.Bytes, Error]:
 
 public function metadata(path: str) -> Result[Metadata, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_metadata = zero[c.mt_fs_metadata]
     var raw_error = zero[c.mt_fs_error]
@@ -248,7 +248,7 @@ public function metadata(path: str) -> Result[Metadata, Error]:
 
 public function write_text(path: str, content: str) -> Result[bool, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_error = zero[c.mt_fs_error]
     let status_code = c.mt_fs_write_text(storage.to_cstr(path), content.data, content.len, raw_error)
@@ -260,7 +260,7 @@ public function write_text(path: str, content: str) -> Result[bool, Error]:
 
 public function write_bytes(path: str, content: span[ubyte]) -> Result[bool, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_error = zero[c.mt_fs_error]
     let status_code = c.mt_fs_write_bytes(storage.to_cstr(path), content.data, content.len, raw_error)
@@ -272,7 +272,7 @@ public function write_bytes(path: str, content: span[ubyte]) -> Result[bool, Err
 
 public function set_permissions(path: str, mode: int) -> Result[bool, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_error = zero[c.mt_fs_error]
     let status_code = c.mt_fs_set_permissions(storage.to_cstr(path), mode, raw_error)
@@ -284,7 +284,7 @@ public function set_permissions(path: str, mode: int) -> Result[bool, Error]:
 
 public function create_directories(path: str) -> Result[bool, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_error = zero[c.mt_fs_error]
     let status_code = c.mt_fs_create_directories(storage.to_cstr(path), raw_error)
@@ -307,7 +307,7 @@ public function copy_entry(source_path: str, target_path: str) -> Result[bool, E
                 return Result[bool, Error].failure(error= payload.error)
             Result.success as payload:
                 var data = payload.value
-                defer data.release()
+                defer: data.release()
                 return write_bytes(target_path, data.as_span())
 
     if is_directory(source_path):
@@ -322,7 +322,7 @@ public function copy_entry(source_path: str, target_path: str) -> Result[bool, E
                 return Result[bool, Error].failure(error= payload.error)
             Result.success as payload:
                 var entries = payload.value
-                defer entries.release()
+                defer: entries.release()
 
                 var index: ptr_uint = 0
                 while index < entries.len():
@@ -359,7 +359,7 @@ public function copy_entry(source_path: str, target_path: str) -> Result[bool, E
 
 public function remove(path: str) -> Result[bool, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_error = zero[c.mt_fs_error]
     let status_code = c.mt_fs_remove(storage.to_cstr(path), raw_error)
@@ -376,7 +376,7 @@ public function remove_tree(path: str) -> Result[bool, Error]:
                 return Result[bool, Error].failure(error= payload.error)
             Result.success as payload:
                 var entries = payload.value
-                defer entries.release()
+                defer: entries.release()
 
                 var index: ptr_uint = 0
                 while index < entries.len():
@@ -404,9 +404,9 @@ public function remove_tree(path: str) -> Result[bool, Error]:
 
 public function rename(source_path: str, target_path: str) -> Result[bool, Error]:
     var source_storage = arena.create(source_path.len + 1)
-    defer source_storage.release()
+    defer: source_storage.release()
     var target_storage = arena.create(target_path.len + 1)
-    defer target_storage.release()
+    defer: target_storage.release()
 
     var raw_error = zero[c.mt_fs_error]
     let status_code = c.mt_fs_rename(
@@ -501,7 +501,7 @@ public function temporary_directory() -> string.String:
 
 public function canonicalize(path: str) -> Result[string.String, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_text = zero[c.mt_fs_string]
     var raw_error = zero[c.mt_fs_error]
@@ -520,7 +520,7 @@ public function create_temporary_directory(parent_dir: str, prefix: str) -> Resu
         ].failure(error= static_error("fs.create_temporary_directory requires a non-empty prefix"))
 
     var storage = arena.create(parent_dir.len + prefix.len + 2)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_text = zero[c.mt_fs_string]
     var raw_error = zero[c.mt_fs_error]
@@ -544,7 +544,7 @@ public function create_temporary_directory(parent_dir: str, prefix: str) -> Resu
 
 public function create_temporary_directory_in_system_temp(prefix: str) -> Result[string.String, Error]:
     var root = temporary_directory()
-    defer root.release()
+    defer: root.release()
     return create_temporary_directory(root.as_str(), prefix)
 
 
@@ -556,7 +556,7 @@ public function create_temporary_file(parent_dir: str, prefix: str, suffix: str)
         ].failure(error= static_error("fs.create_temporary_file requires a non-empty prefix"))
 
     var storage = arena.create(parent_dir.len + prefix.len + suffix.len + 3)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_text = zero[c.mt_fs_string]
     var raw_error = zero[c.mt_fs_error]
@@ -578,13 +578,13 @@ public function create_temporary_file(parent_dir: str, prefix: str, suffix: str)
 
 public function create_temporary_file_in_system_temp(prefix: str, suffix: str) -> Result[string.String, Error]:
     var root = temporary_directory()
-    defer root.release()
+    defer: root.release()
     return create_temporary_file(root.as_str(), prefix, suffix)
 
 
 public function list_entries(path: str) -> Result[Entries, Error]:
     var storage = arena.create(path.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     var raw_entries = zero[c.mt_fs_entries]
     var raw_error = zero[c.mt_fs_error]
@@ -659,7 +659,7 @@ function collect_files_recursive(path: str, output: ref[vec.Vec[string.String]])
             return Result[bool, Error].failure(error= payload.error)
         Result.success as payload:
             var entries = payload.value
-            defer entries.release()
+            defer: entries.release()
 
             var index: ptr_uint = 0
             while index < entries.len():

data/std/goap.mt

@@ -233,9 +233,9 @@ extending Planner[World, Goal, Context]:
 
     public editable function plan(context: ref[Context], initial_world: World, goal: Goal) -> PlanningResult[World]:
         var nodes = vec.Vec[SearchNode[World]].create()
-        defer nodes.release()
+        defer: nodes.release()
         var open_list = vec.Vec[ptr_uint].create()
-        defer open_list.release()
+        defer: open_list.release()
 
         nodes.push(
             SearchNode[World](

data/std/http/server.mt

@@ -289,11 +289,11 @@ function ascii_case_equal(left: str, right: str) -> bool:
 
 public async function write_response(stream: net.TcpStream, response: ref[Response]) -> Result[ptr_uint, net.Error]:
     var header_text = string.String.with_capacity(256)
-    defer header_text.release()
+    defer: header_text.release()
 
     let reason_str = response.reason.as_str()
     var status_text = string.String.create()
-    defer status_text.release()
+    defer: status_text.release()
     append_ptr_uint(ref_of(status_text), ptr_uint<-response.status_code)
 
     header_text.append("HTTP/1.1 ")
@@ -303,7 +303,7 @@ public async function write_response(stream: net.TcpStream, response: ref[Respon
     header_text.append("\r\n")
 
     var body_len_text = string.String.create()
-    defer body_len_text.release()
+    defer: body_len_text.release()
     append_ptr_uint(ref_of(body_len_text), response.body.len)
 
     var has_content_type = false
@@ -521,10 +521,10 @@ function has_header_end(data: span[ubyte]) -> bool:
 
 async function send_error(stream: net.TcpStream, code: int, message: str) -> void:
     var code_str = fmt.to_string_int(code)
-    defer code_str.release()
+    defer: code_str.release()
     let body_text = f"<html><body><h1>#{code_str.as_str()} #{message}</h1></body></html>\r\n"
     var body_len_str = fmt.to_string_ptr_uint(body_text.len)
-    defer body_len_str.release()
+    defer: body_len_str.release()
     let header_text = f"HTTP/1.1 #{code_str.as_str()} #{message}\r\nContent-Type: text/html\r\nContent-Length: #{body_len_str.as_str()}\r\nConnection: close\r\n\r\n"
     await stream.write_bytes(text.as_byte_span(header_text))
     await stream.write_bytes(text.as_byte_span(body_text))
@@ -539,9 +539,9 @@ async function send_file_response(
     head_only: bool
 ) -> void:
     var code_str = fmt.to_string_int(code)
-    defer code_str.release()
+    defer: code_str.release()
     var body_len_str = fmt.to_string_ptr_uint(body.len)
-    defer body_len_str.release()
+    defer: body_len_str.release()
     let header_text = f"HTTP/1.1 #{code_str.as_str()} #{message}\r\nContent-Type: #{content_type}\r\nContent-Length: #{body_len_str.as_str()}\r\nConnection: close\r\n\r\n"
     await stream.write_bytes(text.as_byte_span(header_text))
     if not head_only:
@@ -620,13 +620,13 @@ async function serve_directory_index(stream: net.TcpStream, dir_path: str, url_p
     var entries = fs.list_entries(dir_path) else:
         await send_error(stream, 500, "Internal Server Error")
         return
-    defer entries.release()
+    defer: entries.release()
 
     var names = vec.Vec[string.String].create()
-    defer release_string_vec(ref_of(names))
+    defer: release_string_vec(ref_of(names))
 
     var is_dir = vec.Vec[bool].create()
-    defer is_dir.release()
+    defer: is_dir.release()
 
     var index: ptr_uint = 0
     while index < entries.len():
@@ -635,16 +635,16 @@ async function serve_directory_index(stream: net.TcpStream, dir_path: str, url_p
             let entry_name = entry_ptr.unwrap()
             let name_str = entry_name
             var child_path = path_ops.join(dir_path, name_str)
-            defer child_path.release()
+            defer: child_path.release()
             let dir_flag = fs.is_directory(child_path.as_str())
             sorted_insert(ref_of(names), ref_of(is_dir), string.String.from_str(name_str), dir_flag)
         index += 1
 
     var body = string.String.with_capacity(4096)
-    defer body.release()
+    defer: body.release()
 
     var escaped_path = html_escape(url_prefix)
-    defer escaped_path.release()
+    defer: escaped_path.release()
 
     body.append("<!DOCTYPE html>\n<html>\n<head><meta charset=\"utf-8\"><title>Index of ")
     body.append(escaped_path.as_str())
@@ -667,10 +667,10 @@ async function serve_directory_index(stream: net.TcpStream, dir_path: str, url_p
             let is_directory = read(dir_flag_ptr)
 
             var line = string.String.with_capacity(name_str.len + 64)
-            defer line.release()
+            defer: line.release()
 
             var escaped_name = html_escape(name_str)
-            defer escaped_name.release()
+            defer: escaped_name.release()
 
             if is_directory:
                 line.append("<a href=\"")
@@ -698,10 +698,10 @@ async function serve_directory_index(stream: net.TcpStream, dir_path: str, url_p
 
 async function handle_connection(stream: net.TcpStream, serve_dir: str) -> void:
     var conn = stream
-    defer conn.release()
+    defer: conn.release()
 
     var buffer = vec.Vec[ubyte].with_capacity(READ_BUFFER_SIZE)
-    defer buffer.release()
+    defer: buffer.release()
 
     var headers_done = false
     while not headers_done:
@@ -750,13 +750,13 @@ async function handle_connection(stream: net.TcpStream, serve_dir: str) -> void:
             url_path = stripped
 
     var file_path = path_ops.join(serve_dir, url_path)
-    defer file_path.release()
+    defer: file_path.release()
 
     let content_result = fs.read_bytes(file_path.as_str())
     match content_result:
         Result.success as content_ok:
             var content = content_ok.value
-            defer content.release()
+            defer: content.release()
 
             let mime = guess_mime(file_path.as_str())
             await send_file_response(conn, 200, "OK", mime, content.as_span(), method.equal("HEAD"))
@@ -786,7 +786,7 @@ async function main(args: span[str]) -> void:
     let serve_dir = parse_serve_dir(args)
 
     var port_str = fmt.to_string_int(port)
-    defer port_str.release()
+    defer: port_str.release()
 
     stdio.print_format("Serving HTTP on http://0.0.0.0:%d (dir: %s)\n", port, serve_dir)
 
@@ -798,7 +798,7 @@ async function main(args: span[str]) -> void:
         stdio.print_format("failed to listen\n")
         return
 
-    defer listener.release()
+    defer: listener.release()
 
     while true:
         let accept_result = await listener.accept()

data/std/http.mt

@@ -399,7 +399,7 @@ function build_request(
 
     if not content_length_seen:
         var content_length = fmt.to_string_ptr_uint(body_length)
-        defer content_length.release()
+        defer: content_length.release()
         append_request_header_line(ref_of(request), "Content-Length", content_length.as_str())
 
     index = 0
@@ -654,7 +654,7 @@ function parse_response_head(header_text: str) -> Result[ResponseHead, Error]:
 
 function decode_buffered_chunked_body(encoded: span[ubyte]) -> Result[bytes.Bytes, Error]:
     var body = vec.Vec[ubyte].with_capacity(encoded.len)
-    defer body.release()
+    defer: body.release()
 
     var cursor: ptr_uint = 0
     while true:
@@ -775,10 +775,10 @@ function parse_buffered_response(raw_response: span[ubyte]) -> Result[Response,
 
 async function read_chunked_body(stream: net.TcpStream, prefix: span[ubyte]) -> Result[bytes.Bytes, Error]:
     var body = vec.Vec[ubyte].with_capacity(prefix.len)
-    defer body.release()
+    defer: body.release()
 
     var buffer = vec.Vec[ubyte].with_capacity(prefix.len + 64)
-    defer buffer.release()
+    defer: buffer.release()
     buffer.append_span(prefix)
 
     var cursor: ptr_uint = 0
@@ -906,7 +906,7 @@ async function read_body(
                 return Result[bytes.Bytes, Error].failure(error = response_error("body exceeded Content-Length"))
 
             var body = vec.Vec[ubyte].with_capacity(total_length)
-            defer body.release()
+            defer: body.release()
 
             body.append_span(prefix)
 
@@ -924,7 +924,7 @@ async function read_body(
             return Result[bytes.Bytes, Error].success(value = bytes.Bytes.copy(body.as_span()))
         Option.none:
             var body = vec.Vec[ubyte].with_capacity(prefix.len)
-            defer body.release()
+            defer: body.release()
 
             body.append_span(prefix)
 
@@ -947,7 +947,7 @@ async function read_body(
 
 async function read_response(stream: net.TcpStream) -> Result[Response, Error]:
     var received = vec.Vec[ubyte].create()
-    defer received.release()
+    defer: received.release()
 
     var header_length: ptr_uint = 0
     var headers_ready = false
@@ -1008,7 +1008,7 @@ async function read_response(stream: net.TcpStream) -> Result[Response, Error]:
 
 async function request_http(parsed: ParsedUrl, request_bytes: span[ubyte]) -> Result[Response, Error]:
     var service = fmt.to_string_int(parsed.port)
-    defer service.release()
+    defer: service.release()
 
     let address_result = await net.resolve_first(parsed.host.as_str(), service.as_str())
     match address_result:
@@ -1016,7 +1016,7 @@ async function request_http(parsed: ParsedUrl, request_bytes: span[ubyte]) -> Re
             return Result[Response, Error].failure(error = status_net_error(address_error_payload.error))
         Result.success as address_payload:
             var address = address_payload.value
-            defer address.release()
+            defer: address.release()
 
             let connect_result = await net.connect(address)
             match connect_result:
@@ -1024,7 +1024,7 @@ async function request_http(parsed: ParsedUrl, request_bytes: span[ubyte]) -> Re
                     return Result[Response, Error].failure(error = status_net_error(connect_error_payload.error))
                 Result.success as connect_payload:
                     var stream = connect_payload.value
-                    defer stream.release()
+                    defer: stream.release()
 
                     let write_result = await stream.write_bytes(request_bytes)
                     match write_result:
@@ -1042,7 +1042,7 @@ async function request_http(parsed: ParsedUrl, request_bytes: span[ubyte]) -> Re
 
 async function read_buffered_tls_response(stream: tls.Stream) -> Result[Response, Error]:
     var received = vec.Vec[ubyte].create()
-    defer received.release()
+    defer: received.release()
 
     while true:
         let chunk_result = await stream.read_once(4096)
@@ -1068,7 +1068,7 @@ async function request_https(parsed: ParsedUrl, request_bytes: span[ubyte]) -> R
             return Result[Response, Error].failure(error = status_tls_error(payload.error))
         Result.success as payload:
             var stream = payload.value
-            defer stream.release()
+            defer: stream.release()
 
             let write_result = await stream.write_bytes(request_bytes)
             match write_result:
@@ -1214,7 +1214,7 @@ public async function request(
             return Result[Response, Error].failure(error = payload.error)
         Result.success as payload:
             var parsed = payload.value
-            defer parsed.release()
+            defer: parsed.release()
 
             let request_result = build_request(parsed, method, headers, body)
             match request_result:
@@ -1222,6 +1222,6 @@ public async function request(
                     return Result[Response, Error].failure(error = request_error_payload.error)
                 Result.success as request_payload:
                     var request_bytes = request_payload.value
-                    defer request_bytes.release()
+                    defer: request_bytes.release()
 
                     return await request_with_transport(parsed, request_bytes.as_span())

data/std/jobs.mt

@@ -53,7 +53,7 @@ function noop_completion(arg: ptr[void]) -> void:
 function stop_pool_state(state: ptr[PoolState]) -> void:
     let mutex = unsafe: read(state).mutex
     mutex.lock()
-    defer mutex.unlock()
+    defer: mutex.unlock()
     unsafe: read(state).stopping = true
     let condition = unsafe: read(state).condition
     condition.broadcast()
@@ -229,7 +229,7 @@ extending Pool:
 
         let mutex = unsafe: read(state).mutex
         mutex.lock()
-        defer mutex.unlock()
+        defer: mutex.unlock()
 
         if unsafe: read(state).stopping:
             return Result[bool, Error].failure(error = jobs_error(-1, "jobs pool is stopping"))
@@ -270,7 +270,7 @@ extending Pool:
 
         let mutex = unsafe: read(state).mutex
         mutex.lock()
-        defer mutex.unlock()
+        defer: mutex.unlock()
         return unsafe: read(state).queued_jobs
 
 
@@ -280,7 +280,7 @@ extending Pool:
 
         let mutex = unsafe: read(state).mutex
         mutex.lock()
-        defer mutex.unlock()
+        defer: mutex.unlock()
         return unsafe: read(state).queued_jobs + read(state).running_jobs
 
 

data/std/json.mt

@@ -375,12 +375,12 @@ function build_raw_value(value: Value) -> Result[ptr[cjson.JSON], Error]:
 
 function render_with_mode(value: Value, pretty: bool) -> Result[string.String, Error]:
     let raw_value = build_raw_value(value)?
-    defer cjson.delete(raw_value)
+    defer: cjson.delete(raw_value)
 
     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(unsafe: rendered_ptr)
         return Result[
             string.String,
             Error
@@ -388,13 +388,13 @@ 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(unsafe: rendered_ptr)
     return Result[string.String, Error].success(value = string.String.from_str(text.chars_as_str(rendered_ptr)))
 
 
 public function parse(text_value: str) -> Result[Value, Error]:
     var storage = arena.create(text_value.len + 1)
-    defer storage.release()
+    defer: storage.release()
 
     let c_text = storage.to_cstr(text_value)
     let raw_value = raw.cJSON_Parse(c_text) else:
@@ -406,7 +406,7 @@ public function parse(text_value: str) -> Result[Value, Error]:
             return Result[Value, Error].failure(error = error_message("json parse failed"))
         return Result[Value, Error].failure(error = Error(message = string.String.from_str(error_text)))
 
-    defer raw.cJSON_Delete(raw_value)
+    defer: raw.cJSON_Delete(raw_value)
     return convert_raw_value(unsafe: ptr[cjson.JSON]?<-raw_value)
 
 

data/std/log.mt

@@ -34,7 +34,7 @@ public function log(level: Level, message: str) -> void:
     if int<-level < int<-global_level:
         return
     var output = string.String.create()
-    defer output.release()
+    defer: output.release()
     output.append("[")
     output.append(level_label(level))
     output.append("] ")

data/std/mem/tracking.mt

@@ -47,7 +47,7 @@ extending Tracker:
             return
 
         var sb = string.String.create()
-        defer sb.release()
+        defer: sb.release()
 
         sb.append("[tracking] ")
         sb.append(fmt.format(f"#{this.entries.len()} leaked allocation(s):\n").as_str())

data/std/net/channel.mt

@@ -154,7 +154,7 @@ function build_packet(
     content: span[ubyte]
 ) -> bytes.Bytes:
     var buffer = vec.Vec[ubyte].with_capacity(header_bytes + content.len)
-    defer buffer.release()
+    defer: buffer.release()
 
     buffer.append_array(encode_uint(header_magic))
     buffer.append_array(encode_uint(sequence))
@@ -275,7 +275,7 @@ async function send_connected_packet(
         ack_bits = unsafe: read(protocol).received_mask
 
     var framed = build_packet(sequence, ack, ack_bits, packet_flags, content)
-    defer framed.release()
+    defer: framed.release()
 
     (await socket.send(framed.as_span()))?
     return Result[bool, net.Error].success(value = true)
@@ -297,7 +297,7 @@ async function send_packet_to(
         ack_bits = unsafe: read(protocol).received_mask
 
     var framed = build_packet(sequence, ack, ack_bits, packet_flags, content)
-    defer framed.release()
+    defer: framed.release()
 
     (await socket.send_to(framed.as_span(), destination))?
     return Result[bool, net.Error].success(value = true)
@@ -475,7 +475,7 @@ extending Channel:
 
     public async editable function recv() -> Result[Option[Message], net.Error]:
         var packet = (await this.socket.recv(this.config.max_payload_bytes + header_bytes))?
-        defer packet.release()
+        defer: packet.release()
 
         let header = decode_header(packet)?
         let protocol = unsafe: ptr_of(this.protocol)

data/std/net/clock.mt

@@ -137,7 +137,7 @@ public async function measure_offset(
 ) -> Result[ClockSync, Error]:
     let t1 = libuv.hrtime()
     var request = build_request(t1)
-    defer request.release()
+    defer: request.release()
     (await socket.send_to(request.as_span(), peer)).map_error(proc(_: net.Error) -> Error:
         clock_error(err_send_failed, "failed to send sync request")
     )?
@@ -154,8 +154,8 @@ public async function measure_offset(
                     )
                 Result.success as dp:
                     var datagram = dp.value
-                    defer datagram.data.release()
-                    defer datagram.source.release()
+                    defer: datagram.data.release()
+                    defer: datagram.source.release()
                     if is_clock_packet(datagram.data.as_span()):
                         let parse_result = parse_response(datagram.data.as_span())
                         match parse_result:
@@ -182,15 +182,15 @@ public async function respond_to_sync(
             match recv_result:
                 Result.success as dp:
                     var datagram = dp.value
-                    defer datagram.data.release()
-                    defer datagram.source.release()
+                    defer: datagram.data.release()
+                    defer: datagram.source.release()
                     if is_clock_packet(datagram.data.as_span()):
                         let parse_result = parse_request(datagram.data.as_span())
                         match parse_result:
                             Result.success as tp:
                                 let t2 = libuv.hrtime()
                                 var resp = build_response(tp.value, t2)
-                                defer resp.release()
+                                defer: resp.release()
                                 let _ = await socket.send_to(resp.as_span(), datagram.source)
                             Result.failure:
                                 pass