mt-lang 0.3.14 → 0.3.17

data/std/fs.linux.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():
@@ -334,9 +334,9 @@ public function copy_entry(source_path: str, target_path: str) -> Result[bool, E
                             ].failure(error= static_error("fs copy entry missing source entry"))
                         Option.some as entry_payload:
                             var child_source = path_ops.join(source_path, entry_payload.value)
-                            defer child_source.release()
+                            defer: child_source.release()
                             var child_target = path_ops.join(target_path, entry_payload.value)
-                            defer child_target.release()
+                            defer: child_target.release()
                             match copy_entry(child_source.as_str(), child_target.as_str()):
                                 Result.failure as child_payload:
                                     return Result[bool, Error].failure(error= child_payload.error)
@@ -357,7 +357,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)
@@ -374,7 +374,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():
@@ -383,7 +383,7 @@ public function remove_tree(path: str) -> Result[bool, Error]:
                             return Result[bool, Error].failure(error= static_error("fs remove tree missing entry"))
                         Option.some as entry_payload:
                             var child_path = path_ops.join(path, entry_payload.value)
-                            defer child_path.release()
+                            defer: child_path.release()
                             match remove_tree(child_path.as_str()):
                                 Result.failure as child_payload:
                                     return Result[bool, Error].failure(error= child_payload.error)
@@ -401,9 +401,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(
@@ -438,7 +438,7 @@ public function find_ancestor_containing(path: str, entry_name: str) -> Option[s
 
     while true:
         var candidate = path_ops.join(current.as_str(), entry_name)
-        defer candidate.release()
+        defer: candidate.release()
         let found = exists(candidate.as_str())
         if found:
             return Option[string.String].some(value= current)
@@ -486,7 +486,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]
@@ -505,7 +505,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]
@@ -529,7 +529,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)
 
 
@@ -541,7 +541,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]
@@ -563,13 +563,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]
@@ -644,7 +644,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/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())