mt-lang 0.3.14 → 0.3.17

data/std/oauth2.mt

@@ -78,7 +78,7 @@ public function generate_pkce() -> Result[PkcePair, Error]:
             random_data.release()
 
             var challenge = crypto.sha256(text.as_byte_span(verifier.as_str()))
-            defer challenge.release()
+            defer: challenge.release()
 
             let challenge_b64 = base64.encode_urlsafe(challenge.as_span())
 
@@ -141,9 +141,9 @@ function append_query_param(target: ref[string.String], key: str, value: str) ->
             target.push_byte(38)
 
     var encoded_key = url.percent_encode(key)
-    defer encoded_key.release()
+    defer: encoded_key.release()
     var encoded_value = url.percent_encode(value)
-    defer encoded_value.release()
+    defer: encoded_value.release()
 
     target.append(encoded_key.as_str())
     target.push_byte(61)
@@ -156,7 +156,7 @@ public async function exchange_code(
     pkce_verifier: Option[str]
 ) -> Result[Tokens, Error]:
     var body_params = vec.Vec[url.FormField].create()
-    defer release_form_fields(ref_of(body_params))
+    defer: release_form_fields(ref_of(body_params))
 
     body_params.push(url.FormField(key = "grant_type", value = "authorization_code"))
     body_params.push(url.FormField(key = "code", value = code))
@@ -170,10 +170,10 @@ public async function exchange_code(
             body_params.push(url.FormField(key = "code_verifier", value = payload.value))
 
     var form_body = url.encode_form(body_params.as_span())
-    defer form_body.release()
+    defer: form_body.release()
 
     var auth_header = build_basic_auth_header(config.client_id.as_str(), config.client_secret.as_str())
-    defer auth_header.release()
+    defer: auth_header.release()
 
     var headers = array[http.RequestHeader, 2](
         http.RequestHeader(name = "Content-Type", value = "application/x-www-form-urlencoded"),
@@ -194,7 +194,7 @@ public async function exchange_code(
             return Result[Tokens, Error].failure(error = http_error_to_oauth(payload.error))
         Result.success as payload:
             var response = payload.value
-            defer response.release()
+            defer: response.release()
 
             let body_str = response.body_as_str() else:
                 return Result[Tokens, Error].failure(error = oauth_error("token response body is not valid UTF-8"))
@@ -226,7 +226,7 @@ function parse_token_response(body_str: str, status_code: int) -> Result[Tokens,
             return Result[Tokens, Error].failure(error = oauth_error("token response is not valid JSON"))
         Result.success as json_payload:
             let json_value = json_payload.value
-            defer json.release_value(json_value)
+            defer: json.release_value(json_value)
 
             if status_code != 200:
                 let object_ptr = json_value.as_object() else:
@@ -306,17 +306,17 @@ public async function refresh_access_token(
     refresh_token: str
 ) -> Result[Tokens, Error]:
     var body_params = vec.Vec[url.FormField].create()
-    defer release_form_fields(ref_of(body_params))
+    defer: release_form_fields(ref_of(body_params))
 
     body_params.push(url.FormField(key = "grant_type", value = "refresh_token"))
     body_params.push(url.FormField(key = "refresh_token", value = refresh_token))
     body_params.push(url.FormField(key = "client_id", value = config.client_id.as_str()))
 
     var form_body = url.encode_form(body_params.as_span())
-    defer form_body.release()
+    defer: form_body.release()
 
     var auth_header = build_basic_auth_header(config.client_id.as_str(), config.client_secret.as_str())
-    defer auth_header.release()
+    defer: auth_header.release()
 
     var headers = array[http.RequestHeader, 2](
         http.RequestHeader(name = "Content-Type", value = "application/x-www-form-urlencoded"),
@@ -337,7 +337,7 @@ public async function refresh_access_token(
             return Result[Tokens, Error].failure(error = http_error_to_oauth(payload.error))
         Result.success as payload:
             var response = payload.value
-            defer response.release()
+            defer: response.release()
 
             let body_str = response.body_as_str() else:
                 return Result[Tokens, Error].failure(error = oauth_error("token response body is not valid UTF-8"))

data/std/path.mt

@@ -54,9 +54,9 @@ public function join(left: str, right: str) -> string.String:
 
 public function relative_path(path: str, base: str) -> Option[string.String]:
     var normalized_path = normalize_separators(path)
-    defer normalized_path.release()
+    defer: normalized_path.release()
     var normalized_base = normalize_separators(base)
-    defer normalized_base.release()
+    defer: normalized_base.release()
 
     let path_text = normalized_path.as_str()
     let base_text = normalized_base.as_str()
@@ -66,11 +66,11 @@ public function relative_path(path: str, base: str) -> Option[string.String]:
         return Option[string.String].none
 
     var path_segments = vec.Vec[Segment].create()
-    defer path_segments.release()
+    defer: path_segments.release()
     collect_normalized_segments(path_text, path_root, ref_of(path_segments))
 
     var base_segments = vec.Vec[Segment].create()
-    defer base_segments.release()
+    defer: base_segments.release()
     collect_normalized_segments(base_text, base_root, ref_of(base_segments))
 
     var common: ptr_uint = 0
@@ -111,9 +111,9 @@ public function relative_path(path: str, base: str) -> Option[string.String]:
 
 public function is_within_root(path: str, root: str) -> bool:
     var normalized_path = normalize_separators(path)
-    defer normalized_path.release()
+    defer: normalized_path.release()
     var normalized_root = normalize_separators(root)
-    defer normalized_root.release()
+    defer: normalized_root.release()
 
     let path_text = normalized_path.as_str()
     let root_text = normalized_root.as_str()
@@ -123,11 +123,11 @@ public function is_within_root(path: str, root: str) -> bool:
         return false
 
     var path_segments = vec.Vec[Segment].create()
-    defer path_segments.release()
+    defer: path_segments.release()
     collect_normalized_segments(path_text, path_root, ref_of(path_segments))
 
     var root_segments = vec.Vec[Segment].create()
-    defer root_segments.release()
+    defer: root_segments.release()
     collect_normalized_segments(root_text, root_root, ref_of(root_segments))
 
     if path_segments.len() < root_segments.len():

data/std/process.mt

@@ -437,7 +437,7 @@ function spawn_internal(
             return Result[ChildProcess, ProcessError].failure(error= payload.error)
         Result.success as payload:
             var prepared = payload.value
-            defer prepared.release()
+            defer: prepared.release()
 
             var raw_handle = zero[c.mt_process_spawn_handle]
             var raw_error = zero[c.mt_process_error]
@@ -478,7 +478,7 @@ function spawn_pty_internal(
             return Result[PtyProcess, ProcessError].failure(error= payload.error)
         Result.success as payload:
             var prepared = payload.value
-            defer prepared.release()
+            defer: prepared.release()
 
             var raw_handle = zero[c.mt_process_pty_handle]
             var raw_error = zero[c.mt_process_error]
@@ -512,7 +512,7 @@ function capture_internal(
             return Result[CaptureResult, ProcessError].failure(error= payload.error)
         Result.success as payload:
             var prepared = payload.value
-            defer prepared.release()
+            defer: prepared.release()
 
             var raw_result = zero[c.mt_process_capture_result]
             var raw_error = zero[c.mt_process_error]
@@ -547,7 +547,7 @@ function spawn_detached_internal(
             return Result[int, ProcessError].failure(error= payload.error)
         Result.success as payload:
             var prepared = payload.value
-            defer prepared.release()
+            defer: prepared.release()
 
             var pid: int = 0
             var raw_error = zero[c.mt_process_error]

data/std/raylib/packed_assets.mt

@@ -113,7 +113,7 @@ public function close_reader(reader: ref[Reader]) -> void:
 public function load_image(reader: pack.Reader, logical_path: str) -> Result[rl.Image, Error]:
     let file_type = detect_file_type(logical_path)?
     var data = map_pack_result(reader.read_bytes(logical_path))?
-    defer data.release()
+    defer: data.release()
 
     let image = rl.load_image_from_memory(file_type, data.as_span())
     if not rl.is_image_valid(image):
@@ -124,7 +124,7 @@ public function load_image(reader: pack.Reader, logical_path: str) -> Result[rl.
 
 public function load_texture(reader: pack.Reader, logical_path: str) -> Result[rl.Texture2D, Error]:
     let image = load_image(reader, logical_path)?
-    defer rl.unload_image(image)
+    defer: rl.unload_image(image)
 
     let texture = rl.load_texture_from_image(image)
     if not rl.is_texture_valid(texture):
@@ -136,7 +136,7 @@ public function load_texture(reader: pack.Reader, logical_path: str) -> Result[r
 public function load_wave(reader: pack.Reader, logical_path: str) -> Result[rl.Wave, Error]:
     let file_type = detect_file_type(logical_path)?
     var data = map_pack_result(reader.read_bytes(logical_path))?
-    defer data.release()
+    defer: data.release()
 
     let wave = rl.load_wave_from_memory(file_type, data.as_span())
     if not rl.is_wave_valid(wave):
@@ -147,7 +147,7 @@ public function load_wave(reader: pack.Reader, logical_path: str) -> Result[rl.W
 
 public function load_sound(reader: pack.Reader, logical_path: str) -> Result[rl.Sound, Error]:
     let wave = load_wave(reader, logical_path)?
-    defer rl.unload_wave(wave)
+    defer: rl.unload_wave(wave)
 
     let sound = rl.load_sound_from_wave(wave)
     if not rl.is_sound_valid(sound):
@@ -173,7 +173,7 @@ public function load_music(reader: pack.Reader, logical_path: str) -> Result[Pac
 
 function open_pack_relative_to_application(pack_name: str) -> Result[pack.Reader, Error]:
     var application_path = application_relative_path(pack_name)
-    defer application_path.release()
+    defer: application_path.release()
 
     let application_result = pack.open(application_path.as_str())
     match application_result:

data/std/serialize.mt

@@ -52,7 +52,7 @@ extending bin.Reader:
                 return Result[T, bin.Error].failure(error = p.error)
             Result.success as bp:
                 var raw_bytes = bp.value
-                defer raw_bytes.release()
+                defer: raw_bytes.release()
 
                 let src_ptr = raw_bytes.data else:
                     return Result[T, bin.Error].failure(

data/std/tar.mt

@@ -358,7 +358,7 @@ function append_file_entry(source_path: str, archive_path: str, output: ref[vec.
             return Result[bool, Error].failure(error = take_fs_error(payload.error))
         Result.success as payload:
             var data = payload.value
-            defer data.release()
+            defer: data.release()
             output.append_span(data.as_span())
             append_padding(output, data.len)
             return Result[bool, Error].success(value = true)
@@ -387,14 +387,14 @@ function append_directory_tree(
             return Result[bool, Error].failure(error = take_fs_error(payload.error))
         Result.success as payload:
             var entries = payload.value
-            defer entries.release()
+            defer: entries.release()
 
             match copy_sorted_entry_names(entries, include_hidden):
                 Result.failure as names_payload:
                     return Result[bool, Error].failure(error = names_payload.error)
                 Result.success as names_payload:
                     var names = names_payload.value
-                    defer release_string_values(ref_of(names))
+                    defer: release_string_values(ref_of(names))
 
                     var index: ptr_uint = 0
                     while index < names.len():
@@ -520,10 +520,10 @@ function read_text_field(input: span[ubyte], offset: ptr_uint, field_len: ptr_ui
 
 function parse_entry(input: span[ubyte], offset: ptr_uint) -> Result[ParsedEntry, Error]:
     var name = read_text_field(input, offset + 0, 100)?
-    defer name.release()
+    defer: name.release()
 
     var prefix = read_text_field(input, offset + 345, 155)?
-    defer prefix.release()
+    defer: prefix.release()
 
     let name_text = name.as_str()
     if name_text.len == 0:
@@ -590,7 +590,7 @@ function checked_destination_path(destination_root: str, relative_path: str) ->
             ].failure(error = error_message("tar extract path escapes destination root"))
         Option.some as payload:
             var normalized = payload.value
-            defer normalized.release()
+            defer: normalized.release()
             let normalized_path = normalized.as_str()
             let escapes_parent = normalized_path.len == 2 and normalized_path.byte_at(0) == 46 and normalized_path.byte_at(1) == 46
             if escapes_parent or normalized_path.starts_with("../"):
@@ -648,7 +648,7 @@ public function archive_directory_gzip(
             return Result[bytes.Bytes, Error].failure(error = payload.error)
         Result.success as payload:
             var archive = payload.value
-            defer archive.release()
+            defer: archive.release()
             match gzip.compress_bytes(archive.as_span()):
                 Result.failure as gzip_payload:
                     return Result[bytes.Bytes, Error].failure(error = take_gzip_error(gzip_payload.error))
@@ -668,10 +668,10 @@ public function extract(archive: span[ubyte], destination_root: str) -> Result[b
             return Result[bool, Error].success(value = true)
 
         var entry = parse_entry(archive, offset)?
-        defer entry.release()
+        defer: entry.release()
 
         var destination_path = checked_destination_path(destination_root, entry.path.as_str())?
-        defer destination_path.release()
+        defer: destination_path.release()
 
         if entry.kind == EntryKind.directory:
             fs.create_directories(destination_path.as_str()).map_error(take_fs_error)?
@@ -700,5 +700,5 @@ public function extract(archive: span[ubyte], destination_root: str) -> Result[b
 
 public function extract_gzip(archive: span[ubyte], destination_root: str) -> Result[bool, Error]:
     var decoded = gzip.decompress_bytes(archive).map_error(take_gzip_error)?
-    defer decoded.release()
+    defer: decoded.release()
     return extract(decoded.as_span(), destination_root)

data/std/terminal.mt

@@ -695,7 +695,7 @@ public function flush_stderr() -> Result[bool, Error]:
 
 public function clear_screen() -> Result[bool, Error]:
     var sequence = string.String.with_capacity(8)
-    defer sequence.release()
+    defer: sequence.release()
     append_csi(ref_of(sequence), "2J")
     append_csi(ref_of(sequence), "H")
     return write_stdout_sequence(sequence, "terminal clear screen failed")
@@ -703,21 +703,21 @@ public function clear_screen() -> Result[bool, Error]:
 
 public function clear_line() -> Result[bool, Error]:
     var sequence = string.String.with_capacity(5)
-    defer sequence.release()
+    defer: sequence.release()
     append_csi(ref_of(sequence), "2K")
     return write_stdout_sequence(sequence, "terminal clear line failed")
 
 
 public function cursor_home() -> Result[bool, Error]:
     var sequence = string.String.with_capacity(4)
-    defer sequence.release()
+    defer: sequence.release()
     append_csi(ref_of(sequence), "H")
     return write_stdout_sequence(sequence, "terminal cursor home failed")
 
 
 public function move_cursor(row: int, column: int) -> Result[bool, Error]:
     var sequence = string.String.with_capacity(24)
-    defer sequence.release()
+    defer: sequence.release()
     append_escape(ref_of(sequence))
     sequence.append_format(f"[#{clamp_cursor_position_1based(row)};#{clamp_cursor_position_1based(column)}H")
     return write_stdout_sequence(sequence, "terminal move cursor failed")
@@ -725,35 +725,35 @@ public function move_cursor(row: int, column: int) -> Result[bool, Error]:
 
 public function hide_cursor() -> Result[bool, Error]:
     var sequence = string.String.with_capacity(8)
-    defer sequence.release()
+    defer: sequence.release()
     append_csi(ref_of(sequence), "?25l")
     return write_stdout_sequence(sequence, "terminal hide cursor failed")
 
 
 public function show_cursor() -> Result[bool, Error]:
     var sequence = string.String.with_capacity(8)
-    defer sequence.release()
+    defer: sequence.release()
     append_csi(ref_of(sequence), "?25h")
     return write_stdout_sequence(sequence, "terminal show cursor failed")
 
 
 public function enter_alternate_screen() -> Result[bool, Error]:
     var sequence = string.String.with_capacity(10)
-    defer sequence.release()
+    defer: sequence.release()
     append_csi(ref_of(sequence), "?1049h")
     return write_stdout_sequence(sequence, "terminal alternate screen failed")
 
 
 public function leave_alternate_screen() -> Result[bool, Error]:
     var sequence = string.String.with_capacity(10)
-    defer sequence.release()
+    defer: sequence.release()
     append_csi(ref_of(sequence), "?1049l")
     return write_stdout_sequence(sequence, "terminal alternate screen failed")
 
 
 public function enable_mouse() -> Result[bool, Error]:
     var sequence = string.String.with_capacity(24)
-    defer sequence.release()
+    defer: sequence.release()
     append_csi(ref_of(sequence), "?1000h")
     append_csi(ref_of(sequence), "?1002h")
     append_csi(ref_of(sequence), "?1006h")
@@ -762,7 +762,7 @@ public function enable_mouse() -> Result[bool, Error]:
 
 public function disable_mouse() -> Result[bool, Error]:
     var sequence = string.String.with_capacity(24)
-    defer sequence.release()
+    defer: sequence.release()
     append_csi(ref_of(sequence), "?1006l")
     append_csi(ref_of(sequence), "?1002l")
     append_csi(ref_of(sequence), "?1000l")
@@ -771,7 +771,7 @@ public function disable_mouse() -> Result[bool, Error]:
 
 public function set_foreground(color: Color) -> Result[bool, Error]:
     var sequence = string.String.with_capacity(10)
-    defer sequence.release()
+    defer: sequence.release()
     append_escape(ref_of(sequence))
     sequence.append("[")
     append_color_code(ref_of(sequence), color, false)
@@ -781,7 +781,7 @@ public function set_foreground(color: Color) -> Result[bool, Error]:
 
 public function set_background(color: Color) -> Result[bool, Error]:
     var sequence = string.String.with_capacity(10)
-    defer sequence.release()
+    defer: sequence.release()
     append_escape(ref_of(sequence))
     sequence.append("[")
     append_color_code(ref_of(sequence), color, true)
@@ -791,7 +791,7 @@ public function set_background(color: Color) -> Result[bool, Error]:
 
 public function set_rgb_foreground(red: int, green: int, blue: int) -> Result[bool, Error]:
     var sequence = string.String.with_capacity(24)
-    defer sequence.release()
+    defer: sequence.release()
     append_escape(ref_of(sequence))
     sequence.append_format(
         f"[38;2;#{clamp_color_channel(red)};#{clamp_color_channel(green)};#{clamp_color_channel(blue)}m"
@@ -801,7 +801,7 @@ public function set_rgb_foreground(red: int, green: int, blue: int) -> Result[bo
 
 public function set_rgb_background(red: int, green: int, blue: int) -> Result[bool, Error]:
     var sequence = string.String.with_capacity(24)
-    defer sequence.release()
+    defer: sequence.release()
     append_escape(ref_of(sequence))
     sequence.append_format(
         f"[48;2;#{clamp_color_channel(red)};#{clamp_color_channel(green)};#{clamp_color_channel(blue)}m"
@@ -811,7 +811,7 @@ public function set_rgb_background(red: int, green: int, blue: int) -> Result[bo
 
 public function set_bold(enabled: bool) -> Result[bool, Error]:
     var sequence = string.String.with_capacity(6)
-    defer sequence.release()
+    defer: sequence.release()
     if enabled:
         append_csi(ref_of(sequence), "1m")
     else:
@@ -821,7 +821,7 @@ public function set_bold(enabled: bool) -> Result[bool, Error]:
 
 public function set_underline(enabled: bool) -> Result[bool, Error]:
     var sequence = string.String.with_capacity(6)
-    defer sequence.release()
+    defer: sequence.release()
     if enabled:
         append_csi(ref_of(sequence), "4m")
     else:
@@ -831,7 +831,7 @@ public function set_underline(enabled: bool) -> Result[bool, Error]:
 
 public function reset_style() -> Result[bool, Error]:
     var sequence = string.String.with_capacity(5)
-    defer sequence.release()
+    defer: sequence.release()
     append_csi(ref_of(sequence), "0m")
     return write_stdout_sequence(sequence, "terminal style reset failed")
 
@@ -958,7 +958,7 @@ extending Terminal:
             return Result[Option[Event], Error].success(value= Option[Event].some(value= ev.unwrap()))
 
         var bytes = read_stdin(timeout_ms)?
-        defer bytes.release()
+        defer: bytes.release()
         if not bytes.is_empty():
             this.input.append_span(bytes.as_span())
 

data/std/tls.mt

@@ -335,7 +335,7 @@ function end_stream_operation(state: ptr[StreamState]) -> void:
 
 async function handshake_on(runtime: aio.Runtime, state_raw: ptr[StreamState]?) -> Result[bool, Error]:
     let state = begin_stream_operation(state_raw)?
-    defer end_stream_operation(state)
+    defer: end_stream_operation(state)
 
     while true:
         let client = unsafe: read(state).client else:
@@ -366,7 +366,7 @@ async function write_on(
         return Result[ptr_uint, Error].success(value = 0)
 
     let state = begin_stream_operation(state_raw)?
-    defer end_stream_operation(state)
+    defer: end_stream_operation(state)
 
     var offset: ptr_uint = 0
     while offset < content.len:
@@ -411,7 +411,7 @@ async function read_once_on(
         return Result[bytes.Bytes, Error].failure(error = tls_error("tls read requires max_bytes > 0"))
 
     let state = begin_stream_operation(state_raw)?
-    defer end_stream_operation(state)
+    defer: end_stream_operation(state)
 
     let buffer = heap.must_alloc[ubyte](max_bytes)
     while true:
@@ -449,7 +449,7 @@ async function read_once_on(
 
 async function shutdown_on(runtime: aio.Runtime, state_raw: ptr[StreamState]?) -> Result[bool, Error]:
     let state = begin_stream_operation(state_raw)?
-    defer end_stream_operation(state)
+    defer: end_stream_operation(state)
 
     while true:
         let client = unsafe: read(state).client else:
@@ -470,7 +470,7 @@ async function shutdown_on(runtime: aio.Runtime, state_raw: ptr[StreamState]?) -
 
 public async function connect_on(runtime: aio.Runtime, host: str, port: int) -> Result[Stream, Error]:
     var service = fmt.to_string_int(port)
-    defer service.release()
+    defer: service.release()
 
     let addresses_result = await net.resolve_all_on(runtime, host, service.as_str())
     match addresses_result:
@@ -478,7 +478,7 @@ public async function connect_on(runtime: aio.Runtime, host: str, port: int) ->
             return Result[Stream, Error].failure(error = take_net_error(payload.error))
         Result.success as payload:
             var addresses = payload.value
-            defer release_socket_addresses(ref_of(addresses))
+            defer: release_socket_addresses(ref_of(addresses))
 
             var last_error = tls_error("tls connect failed")
             var last_error_owned = true
@@ -523,7 +523,7 @@ public async function client_on(runtime: aio.Runtime, host: str, transport: net.
         Result.success as payload:
             var raw_client: ptr[c.mt_tls_client]? = null
             var host_storage = arena.create(host.len + 1)
-            defer host_storage.release()
+            defer: host_storage.release()
 
             var raw_error = zero[c.mt_tls_error]
             let create_status = c.mt_tls_client_create(host_storage.to_cstr(host), payload.value, raw_client, raw_error)
@@ -598,7 +598,7 @@ extending Stream:
 
 public function exchange(host: str, port: int, request: span[ubyte]) -> Result[bytes.Bytes, Error]:
     var host_storage = arena.create(host.len + 1)
-    defer host_storage.release()
+    defer: host_storage.release()
 
     var raw_response = zero[c.mt_tls_bytes]
     var raw_error = zero[c.mt_tls_error]

data/std/uri.mt

@@ -7,7 +7,7 @@ const FILE_URI_PREFIX: str = "file://"
 
 public function file_uri_from_path(path_text: str) -> string.String:
     var normalized = path.normalize_separators(path_text)
-    defer normalized.release()
+    defer: normalized.release()
 
     var result = string.String.from_str(FILE_URI_PREFIX)
     append_percent_encoded_path(ref_of(result), normalized.as_str())

data/std/utility.mt

@@ -152,7 +152,7 @@ extending Action[Context]:
             return 0.0
 
         var scores = vec.Vec[float].with_capacity(n)
-        defer scores.release()
+        defer: scores.release()
 
         for entry in this.considerations:
             unsafe:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.3.14
+  version: 0.3.17
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -158,7 +158,6 @@ files:
 - lib/milk_tea/bindings/bindgen/emitter.rb
 - lib/milk_tea/bindings/bindgen/overrides.rb
 - lib/milk_tea/bindings/bindgen/type_mapper.rb
-- lib/milk_tea/bindings/cli.rb
 - lib/milk_tea/bindings/imported_bindings.rb
 - lib/milk_tea/bindings/imported_bindings/defaults.rb
 - lib/milk_tea/bindings/imported_bindings/generator.rb
@@ -185,7 +184,7 @@ files:
 - lib/milk_tea/core.rb
 - lib/milk_tea/core/ast.rb
 - lib/milk_tea/core/async_runtime_installer.rb
-- lib/milk_tea/core/binding_types.rb
+- lib/milk_tea/core/bindings.rb
 - lib/milk_tea/core/bindings/attribute_binding.rb
 - lib/milk_tea/core/bindings/function_binding.rb
 - lib/milk_tea/core/bindings/module_binding.rb
@@ -203,9 +202,7 @@ files:
 - lib/milk_tea/core/c_backend/type_collectors.rb
 - lib/milk_tea/core/c_backend/type_declaration.rb
 - lib/milk_tea/core/c_backend/type_system.rb
-- lib/milk_tea/core/compatibility_helpers.rb
 - lib/milk_tea/core/compile_time.rb
-- lib/milk_tea/core/compile_time/const_eval.rb
 - lib/milk_tea/core/control_flow.rb
 - lib/milk_tea/core/control_flow/builder.rb
 - lib/milk_tea/core/control_flow/constant_propagation.rb
@@ -218,6 +215,7 @@ files:
 - lib/milk_tea/core/control_flow/termination.rb
 - lib/milk_tea/core/cst.rb
 - lib/milk_tea/core/cst_builder.rb
+- lib/milk_tea/core/intrinsics.rb
 - lib/milk_tea/core/ir.rb
 - lib/milk_tea/core/keywords.rb
 - lib/milk_tea/core/lexer.rb
@@ -232,8 +230,8 @@ files:
 - lib/milk_tea/core/lexer/trivia.rb
 - lib/milk_tea/core/lowering.rb
 - lib/milk_tea/core/lowering/artifacts.rb
-- lib/milk_tea/core/lowering/async.rb
 - lib/milk_tea/core/lowering/async/analysis.rb
+- lib/milk_tea/core/lowering/async/frame_builder.rb
 - lib/milk_tea/core/lowering/async/lowering.rb
 - lib/milk_tea/core/lowering/async/normalization.rb
 - lib/milk_tea/core/lowering/block.rb
@@ -253,7 +251,6 @@ files:
 - lib/milk_tea/core/lowering/utils.rb
 - lib/milk_tea/core/module_binder.rb
 - lib/milk_tea/core/module_loader.rb
-- lib/milk_tea/core/module_loader/errors.rb
 - lib/milk_tea/core/module_path_resolver.rb
 - lib/milk_tea/core/module_roots.rb
 - lib/milk_tea/core/parser.rb
@@ -294,7 +291,7 @@ files:
 - lib/milk_tea/core/types/registry.rb
 - lib/milk_tea/core/types/visitor.rb
 - lib/milk_tea/dap.rb
-- lib/milk_tea/dap/backends/lldb_dap.rb
+- lib/milk_tea/dap/lldb_dap_backend.rb
 - lib/milk_tea/dap/protocol.rb
 - lib/milk_tea/dap/server.rb
 - lib/milk_tea/dap/server/breakpoints.rb
@@ -361,6 +358,7 @@ files:
 - lib/milk_tea/packages/version.rb
 - lib/milk_tea/tooling.rb
 - lib/milk_tea/tooling/asset_pack.rb
+- lib/milk_tea/tooling/bindgen_cli.rb
 - lib/milk_tea/tooling/build.rb
 - lib/milk_tea/tooling/build_cache.rb
 - lib/milk_tea/tooling/cli.rb
@@ -605,7 +603,7 @@ metadata:
   homepage_uri: https://teefan.github.io/mt-lang/
   source_code_uri: https://github.com/teefan/mt-lang
 post_install_message: |
-  Milk Tea 0.3.14 installed!
+  Milk Tea 0.3.17 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH