mt-lang 0.3.13 → 0.3.16

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (71) hide show
  1. checksums.yaml +4 -4
  2. data/README.md +5 -5
  3. data/docs/index.html +31 -23
  4. data/docs/language-design.md +13 -17
  5. data/docs/language-manual.md +19 -7
  6. data/lib/milk_tea/base.rb +1 -1
  7. data/lib/milk_tea/core/ast.rb +2 -2
  8. data/lib/milk_tea/core/control_flow/builder.rb +62 -2
  9. data/lib/milk_tea/core/lowering/async/analysis.rb +3 -9
  10. data/lib/milk_tea/core/lowering/async/lowering.rb +2 -10
  11. data/lib/milk_tea/core/lowering/async/normalization.rb +2 -7
  12. data/lib/milk_tea/core/lowering/block.rb +1 -5
  13. data/lib/milk_tea/core/lowering/expressions.rb +47 -3
  14. data/lib/milk_tea/core/lowering/proc.rb +1 -5
  15. data/lib/milk_tea/core/lowering/resolve.rb +26 -2
  16. data/lib/milk_tea/core/lowering/scans.rb +3 -1
  17. data/lib/milk_tea/core/lowering/utils.rb +7 -28
  18. data/lib/milk_tea/core/parser/statements.rb +18 -12
  19. data/lib/milk_tea/core/pretty_printer/ast_formatter.rb +3 -11
  20. data/lib/milk_tea/core/semantic_analyzer/analysis_context.rb +2 -3
  21. data/lib/milk_tea/core/semantic_analyzer/flow_refinement.rb +1 -1
  22. data/lib/milk_tea/core/semantic_analyzer/function_binding.rb +1 -2
  23. data/lib/milk_tea/core/semantic_analyzer/nullability.rb +2 -4
  24. data/lib/milk_tea/core/semantic_analyzer/statements.rb +2 -8
  25. data/lib/milk_tea/core/semantic_analyzer/type_compatibility.rb +29 -2
  26. data/lib/milk_tea/core/types.rb +0 -6
  27. data/lib/milk_tea/tooling/linter/imports_platform.rb +2 -4
  28. data/lib/milk_tea/tooling/linter/release_rules.rb +1 -6
  29. data/lib/milk_tea/tooling/linter/source_helpers.rb +0 -6
  30. data/lib/milk_tea/tooling/linter/visitors.rb +4 -8
  31. data/lib/milk_tea/tooling/sexpr_dumper.rb +2 -0
  32. data/std/asset_pack.mt +1 -1
  33. data/std/async/libuv_runtime.mt +6 -6
  34. data/std/async/mailbox.mt +4 -4
  35. data/std/{cell.mt → box.mt} +9 -9
  36. data/std/cookie.mt +2 -2
  37. data/std/crypto.mt +1 -1
  38. data/std/curl/runtime.mt +10 -10
  39. data/std/fs.linux.mt +26 -26
  40. data/std/fs.windows.mt +22 -22
  41. data/std/goap.mt +2 -2
  42. data/std/http/server.mt +21 -21
  43. data/std/http.mt +14 -14
  44. data/std/jobs.mt +4 -4
  45. data/std/json.mt +5 -5
  46. data/std/log.mt +1 -1
  47. data/std/mem/tracking.mt +1 -1
  48. data/std/net/channel.mt +4 -4
  49. data/std/net/clock.mt +6 -6
  50. data/std/net/discovery.mt +7 -7
  51. data/std/net/lobby.mt +10 -10
  52. data/std/net/manager.mt +1 -1
  53. data/std/net/mux.mt +4 -4
  54. data/std/net/nat.mt +4 -4
  55. data/std/net/packet.mt +3 -3
  56. data/std/net/punch.mt +3 -3
  57. data/std/net/rpc.mt +3 -3
  58. data/std/net/session.mt +15 -15
  59. data/std/net/stun.mt +4 -4
  60. data/std/net/turn.mt +4 -4
  61. data/std/oauth2.mt +12 -12
  62. data/std/path.mt +8 -8
  63. data/std/process.mt +4 -4
  64. data/std/raylib/packed_assets.mt +5 -5
  65. data/std/serialize.mt +1 -1
  66. data/std/tar.mt +10 -10
  67. data/std/terminal.mt +18 -18
  68. data/std/tls.mt +8 -8
  69. data/std/uri.mt +1 -1
  70. data/std/utility.mt +1 -1
  71. metadata +3 -3
data/std/http/server.mt CHANGED
@@ -289,11 +289,11 @@ function ascii_case_equal(left: str, right: str) -> bool:
289
289
 
290
290
  public async function write_response(stream: net.TcpStream, response: ref[Response]) -> Result[ptr_uint, net.Error]:
291
291
  var header_text = string.String.with_capacity(256)
292
- defer header_text.release()
292
+ defer: header_text.release()
293
293
 
294
294
  let reason_str = response.reason.as_str()
295
295
  var status_text = string.String.create()
296
- defer status_text.release()
296
+ defer: status_text.release()
297
297
  append_ptr_uint(ref_of(status_text), ptr_uint<-response.status_code)
298
298
 
299
299
  header_text.append("HTTP/1.1 ")
@@ -303,7 +303,7 @@ public async function write_response(stream: net.TcpStream, response: ref[Respon
303
303
  header_text.append("\r\n")
304
304
 
305
305
  var body_len_text = string.String.create()
306
- defer body_len_text.release()
306
+ defer: body_len_text.release()
307
307
  append_ptr_uint(ref_of(body_len_text), response.body.len)
308
308
 
309
309
  var has_content_type = false
@@ -521,10 +521,10 @@ function has_header_end(data: span[ubyte]) -> bool:
521
521
 
522
522
  async function send_error(stream: net.TcpStream, code: int, message: str) -> void:
523
523
  var code_str = fmt.to_string_int(code)
524
- defer code_str.release()
524
+ defer: code_str.release()
525
525
  let body_text = f"<html><body><h1>#{code_str.as_str()} #{message}</h1></body></html>\r\n"
526
526
  var body_len_str = fmt.to_string_ptr_uint(body_text.len)
527
- defer body_len_str.release()
527
+ defer: body_len_str.release()
528
528
  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"
529
529
  await stream.write_bytes(text.as_byte_span(header_text))
530
530
  await stream.write_bytes(text.as_byte_span(body_text))
@@ -539,9 +539,9 @@ async function send_file_response(
539
539
  head_only: bool
540
540
  ) -> void:
541
541
  var code_str = fmt.to_string_int(code)
542
- defer code_str.release()
542
+ defer: code_str.release()
543
543
  var body_len_str = fmt.to_string_ptr_uint(body.len)
544
- defer body_len_str.release()
544
+ defer: body_len_str.release()
545
545
  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"
546
546
  await stream.write_bytes(text.as_byte_span(header_text))
547
547
  if not head_only:
@@ -620,13 +620,13 @@ async function serve_directory_index(stream: net.TcpStream, dir_path: str, url_p
620
620
  var entries = fs.list_entries(dir_path) else:
621
621
  await send_error(stream, 500, "Internal Server Error")
622
622
  return
623
- defer entries.release()
623
+ defer: entries.release()
624
624
 
625
625
  var names = vec.Vec[string.String].create()
626
- defer release_string_vec(ref_of(names))
626
+ defer: release_string_vec(ref_of(names))
627
627
 
628
628
  var is_dir = vec.Vec[bool].create()
629
- defer is_dir.release()
629
+ defer: is_dir.release()
630
630
 
631
631
  var index: ptr_uint = 0
632
632
  while index < entries.len():
@@ -635,16 +635,16 @@ async function serve_directory_index(stream: net.TcpStream, dir_path: str, url_p
635
635
  let entry_name = entry_ptr.unwrap()
636
636
  let name_str = entry_name
637
637
  var child_path = path_ops.join(dir_path, name_str)
638
- defer child_path.release()
638
+ defer: child_path.release()
639
639
  let dir_flag = fs.is_directory(child_path.as_str())
640
640
  sorted_insert(ref_of(names), ref_of(is_dir), string.String.from_str(name_str), dir_flag)
641
641
  index += 1
642
642
 
643
643
  var body = string.String.with_capacity(4096)
644
- defer body.release()
644
+ defer: body.release()
645
645
 
646
646
  var escaped_path = html_escape(url_prefix)
647
- defer escaped_path.release()
647
+ defer: escaped_path.release()
648
648
 
649
649
  body.append("<!DOCTYPE html>\n<html>\n<head><meta charset=\"utf-8\"><title>Index of ")
650
650
  body.append(escaped_path.as_str())
@@ -667,10 +667,10 @@ async function serve_directory_index(stream: net.TcpStream, dir_path: str, url_p
667
667
  let is_directory = read(dir_flag_ptr)
668
668
 
669
669
  var line = string.String.with_capacity(name_str.len + 64)
670
- defer line.release()
670
+ defer: line.release()
671
671
 
672
672
  var escaped_name = html_escape(name_str)
673
- defer escaped_name.release()
673
+ defer: escaped_name.release()
674
674
 
675
675
  if is_directory:
676
676
  line.append("<a href=\"")
@@ -698,10 +698,10 @@ async function serve_directory_index(stream: net.TcpStream, dir_path: str, url_p
698
698
 
699
699
  async function handle_connection(stream: net.TcpStream, serve_dir: str) -> void:
700
700
  var conn = stream
701
- defer conn.release()
701
+ defer: conn.release()
702
702
 
703
703
  var buffer = vec.Vec[ubyte].with_capacity(READ_BUFFER_SIZE)
704
- defer buffer.release()
704
+ defer: buffer.release()
705
705
 
706
706
  var headers_done = false
707
707
  while not headers_done:
@@ -750,13 +750,13 @@ async function handle_connection(stream: net.TcpStream, serve_dir: str) -> void:
750
750
  url_path = stripped
751
751
 
752
752
  var file_path = path_ops.join(serve_dir, url_path)
753
- defer file_path.release()
753
+ defer: file_path.release()
754
754
 
755
755
  let content_result = fs.read_bytes(file_path.as_str())
756
756
  match content_result:
757
757
  Result.success as content_ok:
758
758
  var content = content_ok.value
759
- defer content.release()
759
+ defer: content.release()
760
760
 
761
761
  let mime = guess_mime(file_path.as_str())
762
762
  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:
786
786
  let serve_dir = parse_serve_dir(args)
787
787
 
788
788
  var port_str = fmt.to_string_int(port)
789
- defer port_str.release()
789
+ defer: port_str.release()
790
790
 
791
791
  stdio.print_format("Serving HTTP on http://0.0.0.0:%d (dir: %s)\n", port, serve_dir)
792
792
 
@@ -798,7 +798,7 @@ async function main(args: span[str]) -> void:
798
798
  stdio.print_format("failed to listen\n")
799
799
  return
800
800
 
801
- defer listener.release()
801
+ defer: listener.release()
802
802
 
803
803
  while true:
804
804
  let accept_result = await listener.accept()
data/std/http.mt CHANGED
@@ -399,7 +399,7 @@ function build_request(
399
399
 
400
400
  if not content_length_seen:
401
401
  var content_length = fmt.to_string_ptr_uint(body_length)
402
- defer content_length.release()
402
+ defer: content_length.release()
403
403
  append_request_header_line(ref_of(request), "Content-Length", content_length.as_str())
404
404
 
405
405
  index = 0
@@ -654,7 +654,7 @@ function parse_response_head(header_text: str) -> Result[ResponseHead, Error]:
654
654
 
655
655
  function decode_buffered_chunked_body(encoded: span[ubyte]) -> Result[bytes.Bytes, Error]:
656
656
  var body = vec.Vec[ubyte].with_capacity(encoded.len)
657
- defer body.release()
657
+ defer: body.release()
658
658
 
659
659
  var cursor: ptr_uint = 0
660
660
  while true:
@@ -775,10 +775,10 @@ function parse_buffered_response(raw_response: span[ubyte]) -> Result[Response,
775
775
 
776
776
  async function read_chunked_body(stream: net.TcpStream, prefix: span[ubyte]) -> Result[bytes.Bytes, Error]:
777
777
  var body = vec.Vec[ubyte].with_capacity(prefix.len)
778
- defer body.release()
778
+ defer: body.release()
779
779
 
780
780
  var buffer = vec.Vec[ubyte].with_capacity(prefix.len + 64)
781
- defer buffer.release()
781
+ defer: buffer.release()
782
782
  buffer.append_span(prefix)
783
783
 
784
784
  var cursor: ptr_uint = 0
@@ -906,7 +906,7 @@ async function read_body(
906
906
  return Result[bytes.Bytes, Error].failure(error = response_error("body exceeded Content-Length"))
907
907
 
908
908
  var body = vec.Vec[ubyte].with_capacity(total_length)
909
- defer body.release()
909
+ defer: body.release()
910
910
 
911
911
  body.append_span(prefix)
912
912
 
@@ -924,7 +924,7 @@ async function read_body(
924
924
  return Result[bytes.Bytes, Error].success(value = bytes.Bytes.copy(body.as_span()))
925
925
  Option.none:
926
926
  var body = vec.Vec[ubyte].with_capacity(prefix.len)
927
- defer body.release()
927
+ defer: body.release()
928
928
 
929
929
  body.append_span(prefix)
930
930
 
@@ -947,7 +947,7 @@ async function read_body(
947
947
 
948
948
  async function read_response(stream: net.TcpStream) -> Result[Response, Error]:
949
949
  var received = vec.Vec[ubyte].create()
950
- defer received.release()
950
+ defer: received.release()
951
951
 
952
952
  var header_length: ptr_uint = 0
953
953
  var headers_ready = false
@@ -1008,7 +1008,7 @@ async function read_response(stream: net.TcpStream) -> Result[Response, Error]:
1008
1008
 
1009
1009
  async function request_http(parsed: ParsedUrl, request_bytes: span[ubyte]) -> Result[Response, Error]:
1010
1010
  var service = fmt.to_string_int(parsed.port)
1011
- defer service.release()
1011
+ defer: service.release()
1012
1012
 
1013
1013
  let address_result = await net.resolve_first(parsed.host.as_str(), service.as_str())
1014
1014
  match address_result:
@@ -1016,7 +1016,7 @@ async function request_http(parsed: ParsedUrl, request_bytes: span[ubyte]) -> Re
1016
1016
  return Result[Response, Error].failure(error = status_net_error(address_error_payload.error))
1017
1017
  Result.success as address_payload:
1018
1018
  var address = address_payload.value
1019
- defer address.release()
1019
+ defer: address.release()
1020
1020
 
1021
1021
  let connect_result = await net.connect(address)
1022
1022
  match connect_result:
@@ -1024,7 +1024,7 @@ async function request_http(parsed: ParsedUrl, request_bytes: span[ubyte]) -> Re
1024
1024
  return Result[Response, Error].failure(error = status_net_error(connect_error_payload.error))
1025
1025
  Result.success as connect_payload:
1026
1026
  var stream = connect_payload.value
1027
- defer stream.release()
1027
+ defer: stream.release()
1028
1028
 
1029
1029
  let write_result = await stream.write_bytes(request_bytes)
1030
1030
  match write_result:
@@ -1042,7 +1042,7 @@ async function request_http(parsed: ParsedUrl, request_bytes: span[ubyte]) -> Re
1042
1042
 
1043
1043
  async function read_buffered_tls_response(stream: tls.Stream) -> Result[Response, Error]:
1044
1044
  var received = vec.Vec[ubyte].create()
1045
- defer received.release()
1045
+ defer: received.release()
1046
1046
 
1047
1047
  while true:
1048
1048
  let chunk_result = await stream.read_once(4096)
@@ -1068,7 +1068,7 @@ async function request_https(parsed: ParsedUrl, request_bytes: span[ubyte]) -> R
1068
1068
  return Result[Response, Error].failure(error = status_tls_error(payload.error))
1069
1069
  Result.success as payload:
1070
1070
  var stream = payload.value
1071
- defer stream.release()
1071
+ defer: stream.release()
1072
1072
 
1073
1073
  let write_result = await stream.write_bytes(request_bytes)
1074
1074
  match write_result:
@@ -1214,7 +1214,7 @@ public async function request(
1214
1214
  return Result[Response, Error].failure(error = payload.error)
1215
1215
  Result.success as payload:
1216
1216
  var parsed = payload.value
1217
- defer parsed.release()
1217
+ defer: parsed.release()
1218
1218
 
1219
1219
  let request_result = build_request(parsed, method, headers, body)
1220
1220
  match request_result:
@@ -1222,6 +1222,6 @@ public async function request(
1222
1222
  return Result[Response, Error].failure(error = request_error_payload.error)
1223
1223
  Result.success as request_payload:
1224
1224
  var request_bytes = request_payload.value
1225
- defer request_bytes.release()
1225
+ defer: request_bytes.release()
1226
1226
 
1227
1227
  return await request_with_transport(parsed, request_bytes.as_span())
data/std/jobs.mt CHANGED
@@ -53,7 +53,7 @@ function noop_completion(arg: ptr[void]) -> void:
53
53
  function stop_pool_state(state: ptr[PoolState]) -> void:
54
54
  let mutex = unsafe: read(state).mutex
55
55
  mutex.lock()
56
- defer mutex.unlock()
56
+ defer: mutex.unlock()
57
57
  unsafe: read(state).stopping = true
58
58
  let condition = unsafe: read(state).condition
59
59
  condition.broadcast()
@@ -229,7 +229,7 @@ extending Pool:
229
229
 
230
230
  let mutex = unsafe: read(state).mutex
231
231
  mutex.lock()
232
- defer mutex.unlock()
232
+ defer: mutex.unlock()
233
233
 
234
234
  if unsafe: read(state).stopping:
235
235
  return Result[bool, Error].failure(error = jobs_error(-1, "jobs pool is stopping"))
@@ -270,7 +270,7 @@ extending Pool:
270
270
 
271
271
  let mutex = unsafe: read(state).mutex
272
272
  mutex.lock()
273
- defer mutex.unlock()
273
+ defer: mutex.unlock()
274
274
  return unsafe: read(state).queued_jobs
275
275
 
276
276
 
@@ -280,7 +280,7 @@ extending Pool:
280
280
 
281
281
  let mutex = unsafe: read(state).mutex
282
282
  mutex.lock()
283
- defer mutex.unlock()
283
+ defer: mutex.unlock()
284
284
  return unsafe: read(state).queued_jobs + read(state).running_jobs
285
285
 
286
286
 
data/std/json.mt CHANGED
@@ -375,12 +375,12 @@ function build_raw_value(value: Value) -> Result[ptr[cjson.JSON], Error]:
375
375
 
376
376
  function render_with_mode(value: Value, pretty: bool) -> Result[string.String, Error]:
377
377
  let raw_value = build_raw_value(value)?
378
- defer cjson.delete(raw_value)
378
+ defer: cjson.delete(raw_value)
379
379
 
380
380
  if pretty:
381
381
  let rendered_ptr = cjson.print(raw_value) else:
382
382
  return Result[string.String, Error].failure(error = error_message("json print failed"))
383
- defer raw.cJSON_free(unsafe: rendered_ptr)
383
+ defer: raw.cJSON_free(unsafe: rendered_ptr)
384
384
  return Result[
385
385
  string.String,
386
386
  Error
@@ -388,13 +388,13 @@ function render_with_mode(value: Value, pretty: bool) -> Result[string.String, E
388
388
 
389
389
  let rendered_ptr = cjson.print_unformatted(raw_value) else:
390
390
  return Result[string.String, Error].failure(error = error_message("json print failed"))
391
- defer raw.cJSON_free(unsafe: rendered_ptr)
391
+ defer: raw.cJSON_free(unsafe: rendered_ptr)
392
392
  return Result[string.String, Error].success(value = string.String.from_str(text.chars_as_str(rendered_ptr)))
393
393
 
394
394
 
395
395
  public function parse(text_value: str) -> Result[Value, Error]:
396
396
  var storage = arena.create(text_value.len + 1)
397
- defer storage.release()
397
+ defer: storage.release()
398
398
 
399
399
  let c_text = storage.to_cstr(text_value)
400
400
  let raw_value = raw.cJSON_Parse(c_text) else:
@@ -406,7 +406,7 @@ public function parse(text_value: str) -> Result[Value, Error]:
406
406
  return Result[Value, Error].failure(error = error_message("json parse failed"))
407
407
  return Result[Value, Error].failure(error = Error(message = string.String.from_str(error_text)))
408
408
 
409
- defer raw.cJSON_Delete(raw_value)
409
+ defer: raw.cJSON_Delete(raw_value)
410
410
  return convert_raw_value(unsafe: ptr[cjson.JSON]?<-raw_value)
411
411
 
412
412
 
data/std/log.mt CHANGED
@@ -34,7 +34,7 @@ public function log(level: Level, message: str) -> void:
34
34
  if int<-level < int<-global_level:
35
35
  return
36
36
  var output = string.String.create()
37
- defer output.release()
37
+ defer: output.release()
38
38
  output.append("[")
39
39
  output.append(level_label(level))
40
40
  output.append("] ")
data/std/mem/tracking.mt CHANGED
@@ -47,7 +47,7 @@ extending Tracker:
47
47
  return
48
48
 
49
49
  var sb = string.String.create()
50
- defer sb.release()
50
+ defer: sb.release()
51
51
 
52
52
  sb.append("[tracking] ")
53
53
  sb.append(fmt.format(f"#{this.entries.len()} leaked allocation(s):\n").as_str())
data/std/net/channel.mt CHANGED
@@ -154,7 +154,7 @@ function build_packet(
154
154
  content: span[ubyte]
155
155
  ) -> bytes.Bytes:
156
156
  var buffer = vec.Vec[ubyte].with_capacity(header_bytes + content.len)
157
- defer buffer.release()
157
+ defer: buffer.release()
158
158
 
159
159
  buffer.append_array(encode_uint(header_magic))
160
160
  buffer.append_array(encode_uint(sequence))
@@ -275,7 +275,7 @@ async function send_connected_packet(
275
275
  ack_bits = unsafe: read(protocol).received_mask
276
276
 
277
277
  var framed = build_packet(sequence, ack, ack_bits, packet_flags, content)
278
- defer framed.release()
278
+ defer: framed.release()
279
279
 
280
280
  (await socket.send(framed.as_span()))?
281
281
  return Result[bool, net.Error].success(value = true)
@@ -297,7 +297,7 @@ async function send_packet_to(
297
297
  ack_bits = unsafe: read(protocol).received_mask
298
298
 
299
299
  var framed = build_packet(sequence, ack, ack_bits, packet_flags, content)
300
- defer framed.release()
300
+ defer: framed.release()
301
301
 
302
302
  (await socket.send_to(framed.as_span(), destination))?
303
303
  return Result[bool, net.Error].success(value = true)
@@ -475,7 +475,7 @@ extending Channel:
475
475
 
476
476
  public async editable function recv() -> Result[Option[Message], net.Error]:
477
477
  var packet = (await this.socket.recv(this.config.max_payload_bytes + header_bytes))?
478
- defer packet.release()
478
+ defer: packet.release()
479
479
 
480
480
  let header = decode_header(packet)?
481
481
  let protocol = unsafe: ptr_of(this.protocol)
data/std/net/clock.mt CHANGED
@@ -137,7 +137,7 @@ public async function measure_offset(
137
137
  ) -> Result[ClockSync, Error]:
138
138
  let t1 = libuv.hrtime()
139
139
  var request = build_request(t1)
140
- defer request.release()
140
+ defer: request.release()
141
141
  (await socket.send_to(request.as_span(), peer)).map_error(proc(_: net.Error) -> Error:
142
142
  clock_error(err_send_failed, "failed to send sync request")
143
143
  )?
@@ -154,8 +154,8 @@ public async function measure_offset(
154
154
  )
155
155
  Result.success as dp:
156
156
  var datagram = dp.value
157
- defer datagram.data.release()
158
- defer datagram.source.release()
157
+ defer: datagram.data.release()
158
+ defer: datagram.source.release()
159
159
  if is_clock_packet(datagram.data.as_span()):
160
160
  let parse_result = parse_response(datagram.data.as_span())
161
161
  match parse_result:
@@ -182,15 +182,15 @@ public async function respond_to_sync(
182
182
  match recv_result:
183
183
  Result.success as dp:
184
184
  var datagram = dp.value
185
- defer datagram.data.release()
186
- defer datagram.source.release()
185
+ defer: datagram.data.release()
186
+ defer: datagram.source.release()
187
187
  if is_clock_packet(datagram.data.as_span()):
188
188
  let parse_result = parse_request(datagram.data.as_span())
189
189
  match parse_result:
190
190
  Result.success as tp:
191
191
  let t2 = libuv.hrtime()
192
192
  var resp = build_response(tp.value, t2)
193
- defer resp.release()
193
+ defer: resp.release()
194
194
  let _ = await socket.send_to(resp.as_span(), datagram.source)
195
195
  Result.failure:
196
196
  pass
data/std/net/discovery.mt CHANGED
@@ -130,17 +130,17 @@ public async function announce(
130
130
  return
131
131
  Result.success as addr_p:
132
132
  var announce_addr = addr_p.value
133
- defer announce_addr.release()
133
+ defer: announce_addr.release()
134
134
 
135
135
  match net.udp_bind(announce_addr):
136
136
  Result.failure:
137
137
  return
138
138
  Result.success as bp:
139
139
  var socket = bp.value
140
- defer socket.release()
140
+ defer: socket.release()
141
141
 
142
142
  var response = build_response(game_port, ubyte<-0, max_players, game_name)
143
- defer response.release()
143
+ defer: response.release()
144
144
 
145
145
  while true:
146
146
  let recv_task = socket.recv_from(1500)
@@ -177,7 +177,7 @@ public async function discover_on(
177
177
  )
178
178
  Result.success as la:
179
179
  var local_addr = la.value
180
- defer local_addr.release()
180
+ defer: local_addr.release()
181
181
 
182
182
  match net.udp_bind_on(runtime, local_addr):
183
183
  Result.failure:
@@ -186,7 +186,7 @@ public async function discover_on(
186
186
  )
187
187
  Result.success as bp:
188
188
  var socket = bp.value
189
- defer socket.release()
189
+ defer: socket.release()
190
190
 
191
191
  match socket.set_broadcast(true):
192
192
  0:
@@ -207,10 +207,10 @@ public async function discover_on(
207
207
  )
208
208
  Result.success as broad_addr:
209
209
  var broadcast_addr = broad_addr.value
210
- defer broadcast_addr.release()
210
+ defer: broadcast_addr.release()
211
211
 
212
212
  var probe = build_probe()
213
- defer probe.release()
213
+ defer: probe.release()
214
214
 
215
215
  var results = vec.Vec[ServerInfo].create()
216
216
 
data/std/net/lobby.mt CHANGED
@@ -256,7 +256,7 @@ public async function discover_lobbies_on(
256
256
  return Result[vec.Vec[LobbyInfo], net.Error].failure(error = p.error)
257
257
  Result.success as p:
258
258
  var conn = p.value
259
- defer conn.release()
259
+ defer: conn.release()
260
260
  match await conn.connect_to_peer():
261
261
  Result.failure as pe:
262
262
  return Result[vec.Vec[LobbyInfo], net.Error].failure(error = pe.error)
@@ -389,7 +389,7 @@ async function drain_lobby_client(client: ref[LobbyClient]) -> void:
389
389
  if conn_state == sess.ConnectionState.connected:
390
390
  client.pending_join = false
391
391
  var encoded = encode_string(client.pending_name.as_str())
392
- defer encoded.release()
392
+ defer: encoded.release()
393
393
  let _ = await client.mux.mux_send(lobby_channel, type_join_request, encoded.as_span(), mux.flag_reliable)
394
394
 
395
395
  while true:
@@ -455,7 +455,7 @@ async function handle_join_request(host: ref[LobbyHost], msg: ref[mux.MuxedMessa
455
455
  return
456
456
  Result.success as name_payload:
457
457
  var player_name = name_payload.value
458
- defer player_name.release()
458
+ defer: player_name.release()
459
459
 
460
460
  var first_free: int = -1
461
461
  var slot_index: ubyte = 0
@@ -469,7 +469,7 @@ async function handle_join_request(host: ref[LobbyHost], msg: ref[mux.MuxedMessa
469
469
 
470
470
  if first_free < 0:
471
471
  var reject_data = encode_join_reject(reject_reason_full)
472
- defer reject_data.release()
472
+ defer: reject_data.release()
473
473
  let _ = await host.mux.mux_send(
474
474
  msg.peer_id,
475
475
  lobby_channel,
@@ -489,7 +489,7 @@ async function handle_join_request(host: ref[LobbyHost], msg: ref[mux.MuxedMessa
489
489
  unsafe: read(slot_ptr).occupied = true
490
490
 
491
491
  var accept_data = encode_join_accept(msg.peer_id, slot)
492
- defer accept_data.release()
492
+ defer: accept_data.release()
493
493
  let _ = await host.mux.mux_send(
494
494
  msg.peer_id,
495
495
  lobby_channel,
@@ -516,7 +516,7 @@ async function handle_discover_request(host: ref[LobbyHost], msg: ref[mux.MuxedM
516
516
  var w = bin.Writer.with_capacity(256)
517
517
  encode_lobby_info_payload(ref_of(w), host.info)
518
518
  var payload = w.finish()
519
- defer payload.release()
519
+ defer: payload.release()
520
520
  let _ = await host.mux.mux_send(
521
521
  msg.peer_id,
522
522
  lobby_channel,
@@ -650,7 +650,7 @@ async function broadcast_player_joined(
650
650
  w.write_uint(uint<-new_player_name.len)
651
651
  w.write_bytes(text.as_byte_span(new_player_name))
652
652
  var payload = w.finish()
653
- defer payload.release()
653
+ defer: payload.release()
654
654
 
655
655
  var peer_index: ptr_uint = 0
656
656
  let peer_count = host.mux.peer_count()
@@ -801,11 +801,11 @@ public async function respond_to_beacon(
801
801
  match recv_result:
802
802
  Result.success as dp:
803
803
  var datagram = dp.value
804
- defer datagram.data.release()
805
- defer datagram.source.release()
804
+ defer: datagram.data.release()
805
+ defer: datagram.source.release()
806
806
  if is_beacon_probe(datagram.data.as_span()):
807
807
  var response = build_beacon_response(info)
808
- defer response.release()
808
+ defer: response.release()
809
809
  let _ = await socket.send_to(response.as_span(), datagram.source)
810
810
  Result.failure:
811
811
  pass
data/std/net/manager.mt CHANGED
@@ -418,7 +418,7 @@ async function process_stored_peer_id_events(manager: ref[NetworkManager]) -> vo
418
418
  let player_id = join_event.player_id
419
419
  join_event.release()
420
420
  var assign_data = build_assign_id(player_id)
421
- defer assign_data.release()
421
+ defer: assign_data.release()
422
422
  let _ = await manager.mux_session.mux_send(
423
423
  player_id,
424
424
  channel_system,
data/std/net/mux.mt CHANGED
@@ -382,7 +382,7 @@ async function send_single_conn(
382
382
  send_flags: ubyte
383
383
  ) -> Result[bool, net.Error]:
384
384
  var frame = encode_frame(channel_id, type_id, send_flags, data)
385
- defer frame.release()
385
+ defer: frame.release()
386
386
  if (send_flags & flag_reliable) != 0:
387
387
  let result = await mux.conn.send_reliable(frame.as_span(), 0)
388
388
  return result
@@ -399,7 +399,7 @@ async function send_single_session(
399
399
  send_flags: ubyte
400
400
  ) -> Result[bool, net.Error]:
401
401
  var frame = encode_frame(channel_id, type_id, send_flags, data)
402
- defer frame.release()
402
+ defer: frame.release()
403
403
  if (send_flags & flag_reliable) != 0:
404
404
  let result = await mux.session.send_reliable(peer_id, frame.as_span(), 0)
405
405
  return result
@@ -436,7 +436,7 @@ async function send_fragmented_conn(
436
436
  break
437
437
  let chunk = unsafe: span[ubyte](data = data.data + offset, len = chunk_len)
438
438
  var frame = encode_fragment_frame(channel_id, type_id, frag_flags, group_id, frag_index, total, chunk)
439
- defer frame.release()
439
+ defer: frame.release()
440
440
  if (send_flags & flag_reliable) != 0:
441
441
  let _ = await mux.conn.send_reliable(frame.as_span(), 0)
442
442
  else:
@@ -477,7 +477,7 @@ async function send_fragmented_session(
477
477
  break
478
478
  let chunk = unsafe: span[ubyte](data = data.data + offset, len = chunk_len)
479
479
  var frame = encode_fragment_frame(channel_id, type_id, frag_flags, group_id, frag_index, total, chunk)
480
- defer frame.release()
480
+ defer: frame.release()
481
481
  if (send_flags & flag_reliable) != 0:
482
482
  let _ = await mux.session.send_reliable(peer_id, frame.as_span(), 0)
483
483
  else:
data/std/net/nat.mt CHANGED
@@ -53,7 +53,7 @@ public async function detect(
53
53
  )
54
54
  Result.success as pr:
55
55
  var public_1 = pr.value
56
- defer public_1.release()
56
+ defer: public_1.release()
57
57
 
58
58
  let local_result = socket.local_address()
59
59
  match local_result:
@@ -78,7 +78,7 @@ public async function detect(
78
78
  )
79
79
  Result.success as ar:
80
80
  var public_2 = ar.value
81
- defer public_2.release()
81
+ defer: public_2.release()
82
82
 
83
83
  if not public_1.public_address.equal(public_2.public_address):
84
84
  return Result[NatResult, Error].success(
@@ -107,7 +107,7 @@ public async function detect_default(
107
107
  )
108
108
  Result.success as pp:
109
109
  var primary = pp.value
110
- defer primary.release()
110
+ defer: primary.release()
111
111
 
112
112
  let alt_result = net.ipv4(google_alternate, google_port)
113
113
  match alt_result:
@@ -117,6 +117,6 @@ public async function detect_default(
117
117
  )
118
118
  Result.success as ap:
119
119
  var alternate = ap.value
120
- defer alternate.release()
120
+ defer: alternate.release()
121
121
 
122
122
  return await detect(socket, primary, alternate)
data/std/net/packet.mt CHANGED
@@ -50,7 +50,7 @@ function decode_packet_length(header: bytes.Bytes) -> ptr_uint:
50
50
 
51
51
  function frame_bytes(content: span[ubyte]) -> bytes.Bytes:
52
52
  var framed = vec.Vec[ubyte].with_capacity(frame_header_bytes + content.len)
53
- defer framed.release()
53
+ defer: framed.release()
54
54
 
55
55
  let header = encode_packet_length(content.len)
56
56
  framed.append_array(header)
@@ -157,7 +157,7 @@ extending Stream:
157
157
  return Result[ptr_uint, Error].failure(error = packet_error(-3, "packet exceeds 32-bit frame limit"))
158
158
 
159
159
  var framed = frame_bytes(content)
160
- defer framed.release()
160
+ defer: framed.release()
161
161
 
162
162
  let write_result = await this.stream.write_bytes(framed.as_span())
163
163
  match write_result:
@@ -175,7 +175,7 @@ extending Stream:
175
175
  return Result[bytes.Bytes, Error].failure(error = error_from_net(payload.error))
176
176
  Result.success as payload:
177
177
  var header = payload.value
178
- defer header.release()
178
+ defer: header.release()
179
179
  let packet_length = decode_packet_length(header)
180
180
  if packet_length > this.max_packet_bytes:
181
181
  let discard_result = await discard_exactly(this.stream, packet_length)