mt-lang 0.3.14 → 0.3.16

data/lib/milk_tea/tooling/linter/release_rules.rb

@@ -169,9 +169,6 @@ module MilkTea
         when AST::UnsafeStmt
           _collect_own_released_names(stmt.body, result)
         when AST::DeferStmt
-          if stmt.expression
-            _collect_heap_release_names(stmt.expression, result)
-          end
           _collect_own_released_names(stmt.body, result) if stmt.body.is_a?(Array)
         end
       end
@@ -476,7 +473,6 @@ module MilkTea
         when AST::UnsafeStmt
           _collect_released_names(stmt.body, result)
         when AST::DeferStmt
-          _collect_released_names_in_expr(stmt.expression, result) if stmt.expression
           _collect_released_names(stmt.body, result) if stmt.body.is_a?(Array)
         end
       end
@@ -611,9 +607,8 @@ module MilkTea
       def release_call_in_stmt?(stmt, name)
         return false unless stmt
 
-        # DeferStmt: inline form `defer x.release()` or block form `defer: …`
+        # DeferStmt: block form `defer: …` (inline defers are a single-statement body)
         if stmt.is_a?(AST::DeferStmt)
-          return true if stmt.expression && _expr_has_release?(stmt.expression, name)
           return stmt.body.is_a?(Array) && stmt.body.any? { |s| release_call_in_stmt?(s, name) }
         end
 

data/lib/milk_tea/tooling/linter/source_helpers.rb

@@ -240,8 +240,6 @@ module MilkTea
           expression_column(statement.expression)
         when AST::ReturnStmt
           expression_column(statement.value)
-        when AST::DeferStmt
-          expression_column(statement.expression)
         when AST::ExpressionStmt
           expression_column(statement.expression) || source_statement_span(statement.line)&.first
         else
@@ -267,8 +265,6 @@ module MilkTea
           expression_length(statement.expression)
         when AST::ReturnStmt
           expression_length(statement.value)
-        when AST::DeferStmt
-          expression_length(statement.expression)
         when AST::ExpressionStmt
           expression_length(statement.expression) || source_statement_span(statement.line)&.last
         else
@@ -326,8 +322,6 @@ module MilkTea
           walk_expression_tree(statement.expression, &block)
         when AST::ReturnStmt
           walk_expression_tree(statement.value, &block)
-        when AST::DeferStmt
-          walk_expression_tree(statement.expression, &block)
         when AST::ExpressionStmt
           walk_expression_tree(statement.expression, &block)
         when AST::StaticAssert

data/lib/milk_tea/tooling/linter/visitors.rb

@@ -225,8 +225,7 @@ module MilkTea
           visit_expression(statement.value) if statement.value
           flag_redundant_widening_cast(statement.value) if statement.value
         when AST::DeferStmt
-          visit_expression(statement.expression) if statement.expression
-          with_scope { visit_statement_list(statement.body) } if statement.body
+          with_scope { visit_statement_list(statement.body) }
         when AST::ExpressionStmt
           visit_expression(statement.expression)
           check_useless_expression(statement)
@@ -1252,8 +1251,7 @@ module MilkTea
         when AST::UnsafeStmt
           stmt.body.each { |s| collect_borrows_from_stmt(s, names) }
         when AST::DeferStmt
-          collect_borrows_from_expr(stmt.expression, names) if stmt.expression
-          stmt.body&.each { |s| collect_borrows_from_stmt(s, names) }
+          stmt.body.each { |s| collect_borrows_from_stmt(s, names) }
         when AST::WhenStmt
           collect_borrows_from_expr(stmt.discriminant, names)
           stmt.branches.each { |b| b.body.each { |s| collect_borrows_from_stmt(s, names) } }
@@ -1319,7 +1317,7 @@ module MilkTea
         when AST::UnsafeStmt
           stmt.body.each { |s| collect_writes_from_stmt(s, names) }
         when AST::DeferStmt
-          stmt.body&.each { |s| collect_writes_from_stmt(s, names) }
+          stmt.body.each { |s| collect_writes_from_stmt(s, names) }
         end
       end
 
@@ -1376,9 +1374,7 @@ module MilkTea
           stmt.body.each { |s| location = find_borrow_location_in_stmt(s, name); return location if location }
           nil
         when AST::DeferStmt
-          location = find_borrow_location_in_expr(stmt.expression, name) if stmt.expression
-          return location if location
-          stmt.body&.each { |s| location = find_borrow_location_in_stmt(s, name); return location if location }
+          stmt.body.each { |s| location = find_borrow_location_in_stmt(s, name); return location if location }
           nil
         when AST::WhenStmt
           location = find_borrow_location_in_expr(stmt.discriminant, name)

data/lib/milk_tea/tooling/sexpr_dumper.rb

@@ -38,6 +38,7 @@ module MilkTea
       when Float   then buf << format_float(value)
       when String  then emit_string(value, buf)
       when Symbol  then buf << ":" << value.to_s.tr("_", "-")
+      when Hash, Set then nil
       else buf << escape_string(value.to_s)
       end
     end
@@ -50,6 +51,7 @@ module MilkTea
       buf << "(" << type_name
       members.each do |field|
         val = node.public_send(field)
+        next if val.is_a?(Hash) || val.is_a?(Set)
         buf << " :" << field.to_s << " "
         emit_value(val, buf)
       end

data/std/asset_pack.mt

@@ -187,7 +187,7 @@ function read_entry_metadata(file: stdio.File?) -> Result[EntryMetadata, Error]:
 
 function read_path_matches(file: stdio.File?, path_length: ptr_uint, logical_path: str) -> Result[bool, Error]:
     let path_buffer = heap.must_alloc[ubyte](path_length)
-    defer heap.release(path_buffer)
+    defer: heap.release(path_buffer)
 
     if not read_exact(file, path_buffer, path_length):
         return Result[bool, Error].failure(error= Error.malformed_index)

data/std/async/libuv_runtime.mt

@@ -475,7 +475,7 @@ public function result[T](task: Task[T]) -> T:
     if not completed[T](task):
         fatal(c"async.result called before task completed")
 
-    defer task.release(task.frame)
+    defer: task.release(task.frame)
     return task.take_result(task.frame)
 
 
@@ -484,7 +484,7 @@ public function wait_on[T](runtime: Runtime, task: Task[T]) -> T:
     while not task.ready(task.frame):
         runtime_poll(runtime)
 
-    defer task.release(task.frame)
+    defer: task.release(task.frame)
     return task.take_result(task.frame)
 
 
@@ -503,7 +503,7 @@ public function wait[T](root: proc() -> Task[T]) -> T:
 
     var runtime = runtime_create()
     runtime_activate(runtime)
-    defer runtime_release(ref_of(runtime))
+    defer: runtime_release(ref_of(runtime))
     return wait_on[T](runtime, root())
 
 
@@ -514,7 +514,7 @@ public function run(root: proc() -> Task[void]) -> void:
 
     var runtime = runtime_create()
     runtime_activate(runtime)
-    defer runtime_release(ref_of(runtime))
+    defer: runtime_release(ref_of(runtime))
     run_on(runtime, root())
 
 
@@ -524,7 +524,7 @@ public function with_runtime[T](body: proc(runtime: Runtime) -> T) -> T:
 
     var runtime = runtime_create()
     runtime_activate(runtime)
-    defer runtime_release(ref_of(runtime))
+    defer: runtime_release(ref_of(runtime))
     return body(runtime)
 
 
@@ -535,5 +535,5 @@ public function run_with_runtime(body: proc(runtime: Runtime) -> void) -> void:
 
     var runtime = runtime_create()
     runtime_activate(runtime)
-    defer runtime_release(ref_of(runtime))
+    defer: runtime_release(ref_of(runtime))
     body(runtime)

data/std/async/mailbox.mt

@@ -138,7 +138,7 @@ extending Mailbox[T]:
 
         var mutex = unsafe: read(state).mutex
         mutex.lock()
-        defer mutex.unlock()
+        defer: mutex.unlock()
 
         let handle = unsafe: read(state).handle else:
             return Result[bool, Error].failure(error = mailbox_error("mailbox is closed"))
@@ -161,7 +161,7 @@ extending Mailbox[T]:
 
         var mutex = unsafe: read(state).mutex
         mutex.lock()
-        defer mutex.unlock()
+        defer: mutex.unlock()
         return unsafe: read(state).queue.pop_front()
 
 
@@ -171,7 +171,7 @@ extending Mailbox[T]:
 
         var mutex = unsafe: read(state).mutex
         mutex.lock()
-        defer mutex.unlock()
+        defer: mutex.unlock()
 
         var drained = vec.Vec[T].with_capacity(unsafe: read(state).queue.len())
         while true:
@@ -187,5 +187,5 @@ extending Mailbox[T]:
 
         var mutex = unsafe: read(state).mutex
         mutex.lock()
-        defer mutex.unlock()
+        defer: mutex.unlock()
         return unsafe: read(state).queue.is_empty()

data/std/cookie.mt

@@ -94,7 +94,7 @@ function apply_attribute(cookie: ref[Cookie], attribute_text: str) -> void:
     match eq:
         Option.none:
             var normalized = ascii_lower(attribute_text)
-            defer normalized.release()
+            defer: normalized.release()
 
             if normalized.as_str().equal("secure"):
                 cookie.secure = true
@@ -106,7 +106,7 @@ function apply_attribute(cookie: ref[Cookie], attribute_text: str) -> void:
             let value_text = attribute_text.slice(e.value + 1, attribute_text.len - e.value - 1).trim_ascii_whitespace()
 
             var normalized_key = ascii_lower(key_text)
-            defer normalized_key.release()
+            defer: normalized_key.release()
 
             if normalized_key.as_str().equal("domain"):
                 cookie.domain = Option[string.String].some(value = string.String.from_str(value_text))

data/std/crypto.mt

@@ -23,7 +23,7 @@ public function sha256(data: span[ubyte]) -> bytes.Bytes:
 
 public function sha256_to_str(data: span[ubyte]) -> string.String:
     var digest = sha256(data)
-    defer digest.release()
+    defer: digest.release()
 
     var result = string.String.with_capacity(raw.SHA256_DIGEST_LENGTH * 2)
     var index: ptr_uint = 0

data/std/curl/runtime.mt

@@ -69,21 +69,21 @@ public function get_bytes(url: str) -> Result[bytes.Bytes, curl.Code]:
         return Result[bytes.Bytes, curl.Code].failure(error= curl.Code<-CURLE_URL_MALFORMAT_CODE)
 
     var scratch = arena.create(url.len + 1)
-    defer scratch.release()
+    defer: scratch.release()
 
     let url_cstr = scratch.to_cstr(url)
 
     let global_status = curl.global_init(curl.CURL_GLOBAL_NOTHING)
     if int<-global_status != CURLE_OK_CODE:
         return Result[bytes.Bytes, curl.Code].failure(error= global_status)
-    defer curl.global_cleanup()
+    defer: curl.global_cleanup()
 
     let handle = curl.easy_init() else:
         return Result[bytes.Bytes, curl.Code].failure(error= curl.Code<-CURLE_FAILED_INIT_CODE)
-    defer curl.easy_cleanup(handle)
+    defer: curl.easy_cleanup(handle)
 
     var body = vec.Vec[ubyte].create()
-    defer body.release()
+    defer: body.release()
 
     let write_function_status = easy_setopt_writefunction(handle, write_response_chunk)
     if int<-write_function_status != CURLE_OK_CODE:
@@ -199,7 +199,7 @@ function do_request(
     let global_status = curl.global_init(curl.CURL_GLOBAL_NOTHING)
     if int<-global_status != CURLE_OK_CODE:
         return Result[HttpResponse, HttpError].failure(error = http_error(global_status))
-    defer curl.global_cleanup()
+    defer: curl.global_cleanup()
 
     let handle = curl.easy_init() else:
         return Result[HttpResponse, HttpError].failure(
@@ -208,10 +208,10 @@ function do_request(
                 message = string.String.from_str("curl_easy_init failed")
             )
         )
-    defer curl.easy_cleanup(handle)
+    defer: curl.easy_cleanup(handle)
 
     var buffer = vec.Vec[ubyte].create()
-    defer buffer.release()
+    defer: buffer.release()
 
     let _wfn = easy_setopt_writefunction(handle, write_response_chunk)
     let _wdata = easy_setopt_writedata(handle, unsafe: ptr[void]<-ptr_of(buffer))
@@ -225,7 +225,7 @@ function do_request(
         )
 
     var scratch = arena.create(url.len + 1)
-    defer scratch.release()
+    defer: scratch.release()
 
     let url_cstr = scratch.to_cstr(url)
     let _url = easy_setopt_url(handle, url_cstr)
@@ -237,12 +237,12 @@ function do_request(
     if body.is_some():
         let body_content = body.unwrap()
         var body_scratch = arena.create(body_content.len + 1)
-        defer body_scratch.release()
+        defer: body_scratch.release()
         let _pf = easy_setopt_postfields(handle, body_scratch.to_cstr(body_content))
 
     if method.len > 0 and not method.starts_with("GET"):
         var method_scratch = arena.create(method.len + 1)
-        defer method_scratch.release()
+        defer: method_scratch.release()
         let _method = easy_setopt_customrequest(handle, method_scratch.to_cstr(method))
 
     if method.starts_with("HEAD"):

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():