mt-lang 0.3.13 → 0.3.16

data/lib/milk_tea/core/lowering/expressions.rb

@@ -1506,10 +1506,54 @@ module MilkTea
       return false unless receiver_type.is_a?(Types::VariantArmPayload)
 
       outer = receiver_type.variant_type
-      return field_type == outer if outer.is_a?(Types::Variant)
-      return field_type == outer if outer.is_a?(Types::VariantInstance)
+      return false unless outer.is_a?(Types::Variant) || outer.is_a?(Types::VariantInstance)
 
-      false
+      # The C backend pointer-breaks every cyclic field, including cycles that
+      # run through generic instantiations such as `Option[Atom]` inside `Atom`.
+      # Deref the access whenever the field type can reach the outer variant.
+      type_reaches_target?(field_type, outer)
+    end
+
+    def type_reaches_target?(type, target)
+      type_reaches_target_with_visited?(type, target, {})
+    end
+
+    def type_reaches_target_with_visited?(type, target, visited)
+      return true if type == target
+      return false if visited[type.object_id]
+
+      visited[type.object_id] = true
+      reachability_children(type).any? do |child|
+        type_reaches_target_with_visited?(child, target, visited)
+      end
+    end
+
+    # Structural expansion used by cyclic-field reachability. Mirrors the
+    # CBackend's `aggregate_type_dependencies` so the deref injected for a
+    # pointer-broken cyclic field agrees with the emitted C struct layout.
+    def reachability_children(type)
+      case type
+      when Types::Nullable
+        [type.base]
+      when Types::GenericInstance
+        if pointer_type?(type)
+          []
+        elsif array_type?(type)
+          [array_element_type(type)]
+        else
+          []
+        end
+      when Types::Span
+        [type.element_type]
+      when Types::Struct, Types::StructInstance, Types::Union
+        type.fields.values
+      when Types::Variant, Types::VariantInstance
+        type.arm_names.flat_map { |name| type.arm(name).values }
+      when Types::VariantArmPayload
+        type.fields.values
+      else
+        []
+      end
     end
 
     def lower_compile_time_handle_member(handle, member, type)

data/lib/milk_tea/core/lowering/proc.rb

@@ -180,11 +180,7 @@ module MilkTea
       when AST::ReturnStmt
         collect_proc_captures_from_expression(statement.value, env, local_scopes, captures) if statement.value
       when AST::DeferStmt
-        if statement.body
-          collect_proc_captures_from_statements(statement.body, env, local_scopes + [{}], captures)
-        else
-          collect_proc_captures_from_expression(statement.expression, env, local_scopes, captures)
-        end
+        collect_proc_captures_from_statements(statement.body, env, local_scopes + [{}], captures)
       when AST::ExpressionStmt
         collect_proc_captures_from_expression(statement.expression, env, local_scopes, captures)
       when AST::BreakStmt, AST::ContinueStmt, AST::PassStmt

data/lib/milk_tea/core/lowering/resolve.rb

@@ -1137,9 +1137,33 @@ module MilkTea
       return unless left_type.is_a?(Types::Primitive) && right_type.is_a?(Types::Primitive)
       return unless left_type.integer? && right_type.integer?
       return unless left_type.fixed_width_integer? && right_type.fixed_width_integer?
-      return unless left_type.signed_integer? == right_type.signed_integer?
 
-      left_type.integer_width >= right_type.integer_width ? left_type : right_type
+      # Mirrors the semantic analyzer's rule: same signedness picks the wider
+      # type; mixed signed/unsigned promotes to the narrowest signed type that
+      # holds both operands' full ranges (a strictly-wider signed type covers
+      # an unsigned operand, otherwise widen to the next signed width). Mixing
+      # with a 64-bit unsigned type has no safe signed common type.
+      if left_type.signed_integer? == right_type.signed_integer?
+        return left_type.integer_width >= right_type.integer_width ? left_type : right_type
+      end
+
+      signed_type, unsigned_type = if left_type.signed_integer?
+        [left_type, right_type]
+      else
+        [right_type, left_type]
+      end
+
+      return signed_type if signed_type.integer_width > unsigned_type.integer_width
+
+      signed_type_above_width(unsigned_type.integer_width)
+    end
+
+    def signed_type_above_width(width)
+      case width
+      when 8 then @ctx.types.fetch("short")
+      when 16 then @ctx.types.fetch("int")
+      when 32 then @ctx.types.fetch("long")
+      end
     end
 
     def wider_float_type(left_type, right_type)

data/lib/milk_tea/core/lowering/scans.rb

@@ -144,8 +144,10 @@ module MilkTea
         (expression && expression_uses_pattern?(expression, &predicate)) || block_uses_expression_pattern?(statement.body, &predicate)
       when AST::ReturnStmt
         statement.value && expression_uses_pattern?(statement.value, &predicate)
-      when AST::DeferStmt, AST::ExpressionStmt
+      when AST::ExpressionStmt
         expression_uses_pattern?(statement.expression, &predicate)
+      when AST::DeferStmt
+        block_uses_expression_pattern?(statement.body, &predicate)
       else
         false
       end

data/lib/milk_tea/core/lowering/utils.rb

@@ -760,32 +760,6 @@ module MilkTea
       end
     end
 
-    def lower_defer_cleanup_expression(expression, env:)
-      prepared_setup, prepared_expression, prepared_cleanups = prepare_expression_with_cleanups(
-        expression,
-        env:,
-        expected_type: infer_expression_type(expression, env:),
-        allow_root_statement_foreign: true,
-      )
-
-      lowered = []
-      lowered.concat(prepared_setup)
-      if (foreign_call = foreign_call_info(prepared_expression, env))
-        setup, = lower_foreign_call_statement(
-          foreign_call,
-          env:,
-          expected_type: foreign_call[:binding].type.return_type,
-          statement_position: true,
-          discard_result: true,
-        )
-        lowered.concat(setup)
-      else
-        lowered << IR::ExpressionStmt.new(expression: lower_expression(prepared_expression, env:))
-      end
-      lowered.concat(prepared_cleanups.flat_map(&:itself))
-      lowered
-    end
-
     def lower_defer_cleanup_body(statements, env:, return_type:)
       lower_block(statements, env:, active_defers: [], return_type:, loop_flow: nil, allow_return: false)
     end
@@ -943,7 +917,12 @@ module MilkTea
       payload_type = Types::VariantArmPayload.new(storage_type, arm_name, storage_type.arm(arm_name))
       data_expr = IR::Member.new(receiver: storage_expr, member: "data", type: nil)
       arm_expr = IR::Member.new(receiver: data_expr, member: arm_name, type: payload_type)
-      IR::Member.new(receiver: arm_expr, member: field_name, type: field_type)
+      member_expr = IR::Member.new(receiver: arm_expr, member: field_name, type: field_type)
+      if type_reaches_target?(field_type, payload_type.variant_type)
+        return IR::Unary.new(operator: "*", operand: member_expr, type: field_type)
+      end
+
+      member_expr
     end
 
     def infer_result_propagation_type(expression, env:)
@@ -1156,7 +1135,7 @@ module MilkTea
       cached = cache[text]
       return cached if cached
 
-      identifier = text.gsub(/[^A-Za-z0-9_]+/, "_").gsub(/_+/, "_").sub(/_+$/, "").sub(/^_{2,}/, "_")
+      identifier = text.gsub(/[^A-Za-z0-9_]+/, "_").gsub(/_+/, "_").sub(/_+$/, "").sub(/^_+/, "")
       cache[text] = identifier.empty? ? "value" : identifier
     end
 

data/lib/milk_tea/core/parser/statements.rb

@@ -279,6 +279,18 @@ module MilkTea
         check(:colon) && @current + 1 < @tokens.length && @tokens[@current + 1].type != :newline
       end
 
+      def parse_inline_or_block_body(message)
+        if inline_block_body?
+          consume(:colon, "expected ':' #{message}")
+          @in_inline_block_body = true
+          result = [parse_statement]
+          @in_inline_block_body = false
+          result
+        else
+          parse_block
+        end
+      end
+
       def parse_match_stmt
         token = previous
         line = token.line
@@ -456,7 +468,7 @@ module MilkTea
         consume(:in, "expected 'in' in for loop")
         iterables = [parse_expression]
         iterables << parse_expression while match(:comma)
-        body = parse_block
+        body = parse_inline_or_block_body("after 'in' iterables")
         AST::ForStmt.new(bindings:, iterables:, body:, line:, column: bindings.first.column)
       rescue ParseError => e
         raise unless @recovery_errors
@@ -530,7 +542,7 @@ module MilkTea
         token = previous
         line = token.line
         condition = parse_expression
-        body = parse_block
+        body = parse_inline_or_block_body("after while condition")
         AST::WhileStmt.new(condition:, body:, line:, column: token.column, length: token.lexeme.length)
       rescue ParseError => e
         raise unless @recovery_errors
@@ -580,14 +592,8 @@ module MilkTea
       def parse_defer_stmt
         token = previous
         line = token.line
-        if check(:colon)
-          body = parse_block
-          AST::DeferStmt.new(expression: nil, body:, line:, column: token.column, length: token.lexeme.length)
-        else
-          expression = parse_expression
-          consume_end_of_statement unless block_expression?(expression)
-          AST::DeferStmt.new(expression:, body: nil, line:, column: token.column, length: token.lexeme.length)
-        end
+        body = parse_inline_or_block_body("after defer")
+        AST::DeferStmt.new(body:, line:, column: token.column, length: token.lexeme.length)
       end
 
       def parse_when_decl
@@ -690,7 +696,7 @@ module MilkTea
         consume(:in, "expected 'in' in for loop")
         iterables = [parse_expression]
         iterables << parse_expression while match(:comma)
-        body = parse_block
+        body = parse_inline_or_block_body("after 'in' iterables")
         AST::ForStmt.new(bindings:, iterables:, body:, inline: true, line:, column: bindings.first.column)
       rescue ParseError => e
         raise unless @recovery_errors
@@ -705,7 +711,7 @@ module MilkTea
       def parse_inline_while_stmt(inline_token)
         line = inline_token.line
         condition = parse_expression
-        body = parse_block
+        body = parse_inline_or_block_body("after inline while condition")
         AST::WhileStmt.new(condition:, body:, inline: true, line:, column: inline_token.column, length: inline_token.lexeme.length)
       rescue ParseError => e
         raise unless @recovery_errors

data/lib/milk_tea/core/pretty_printer/ast_formatter.rb

@@ -521,13 +521,9 @@ module MilkTea
         when AST::ReturnStmt
           line(statement.value ? "return #{render_expression(statement.value)}" : "return")
         when AST::DeferStmt
-          if statement.body
-            line("defer:")
-            with_indent do
-              statement.body.each { |nested| emit_statement(nested) }
-            end
-          else
-            line("defer #{render_expression(statement.expression)}")
+          line("defer:")
+          with_indent do
+            statement.body.each { |nested| emit_statement(nested) }
           end
         when AST::ExpressionStmt
           line(render_expression(statement.expression))
@@ -649,10 +645,6 @@ module MilkTea
           "continue"
         when AST::ReturnStmt
           statement.value ? "return #{render_expression(statement.value)}" : "return"
-        when AST::DeferStmt
-          return nil if statement.body
-
-          "defer #{render_expression(statement.expression)}"
         when AST::ExpressionStmt
           render_expression(statement.expression)
         else

data/lib/milk_tea/core/semantic_analyzer/analysis_context.rb

@@ -180,8 +180,7 @@ module MilkTea
         when AST::UnsafeStmt
           statement.body.each { |s| validate_async_statement!(s) }
         when AST::DeferStmt
-          validate_async_expression_support!(statement.expression, context: "defer cleanup") if statement.expression
-          statement.body&.each { |s| validate_async_statement!(s) }
+          statement.body.each { |s| validate_async_statement!(s) }
         when AST::WhenStmt
           statement.branches.each { |branch| branch.body.each { |s| validate_async_statement!(s) } }
           statement.else_body&.each { |s| validate_async_statement!(s) }
@@ -230,7 +229,7 @@ module MilkTea
         when AST::ReturnStmt
           statement.value && expression_contains_await?(statement.value)
         when AST::DeferStmt
-          (statement.expression && expression_contains_await?(statement.expression)) || (statement.body && statements_contain_await?(statement.body))
+          statements_contain_await?(statement.body)
         when AST::ExpressionStmt
           expression_contains_await?(statement.expression)
         else

data/lib/milk_tea/core/semantic_analyzer/flow_refinement.rb

@@ -209,7 +209,7 @@ module MilkTea
             end
           end
         when AST::DeferStmt
-          lines.concat(statement_list_lines(statement.body)) if statement.body
+          lines.concat(statement_list_lines(statement.body))
         when AST::Assignment
           lines << expression_end_line(statement.value)
         when AST::ReturnStmt

data/lib/milk_tea/core/semantic_analyzer/function_binding.rb

@@ -375,9 +375,8 @@ module MilkTea
           body_names = names.dup
           stmt.body&.each { |s| check_stmt_names(s, scopes, binding, body_names) }
         when AST::DeferStmt
-          check_expr_names(stmt.expression, scopes, binding, names) if stmt.expression
           body_names = names.dup
-          stmt.body&.each { |s| check_stmt_names(s, scopes, binding, body_names) }
+          stmt.body.each { |s| check_stmt_names(s, scopes, binding, body_names) }
         when AST::WhenStmt
           check_expr_names(stmt.discriminant, scopes, binding, names)
           stmt.branches.each do |b|

data/lib/milk_tea/core/semantic_analyzer/nullability.rb

@@ -154,8 +154,7 @@ module MilkTea
             statement.iterables.each { |iterable| preassign_local_binding_ids_in_expression(iterable) }
             preassign_local_binding_ids_in_statements(statement.body || [])
           when AST::DeferStmt
-            preassign_local_binding_ids_in_expression(statement.expression) if statement.expression
-            preassign_local_binding_ids_in_statements(statement.body || []) if statement.body
+            preassign_local_binding_ids_in_statements(statement.body)
           when AST::ReturnStmt
             preassign_local_binding_ids_in_expression(statement.value) if statement.value
           when AST::StaticAssert
@@ -319,8 +318,7 @@ module MilkTea
             end
             walk_statements_for_precheck_resolution(statement.body || [], for_scopes, declaration_ids, identifier_ids)
           when AST::DeferStmt
-            walk_expression_for_precheck_resolution(statement.expression, block_scopes, identifier_ids, declaration_ids) if statement.expression
-            walk_statements_for_precheck_resolution(statement.body || [], block_scopes, declaration_ids, identifier_ids) if statement.body
+            walk_statements_for_precheck_resolution(statement.body, block_scopes, declaration_ids, identifier_ids)
           when AST::ExpressionStmt
             walk_expression_for_precheck_resolution(statement.expression, block_scopes, identifier_ids, declaration_ids)
           when AST::ReturnStmt

data/lib/milk_tea/core/semantic_analyzer/statements.rb

@@ -193,14 +193,8 @@ module MilkTea
               line: statement.line,
             )
           when AST::DeferStmt
-            if statement.body
-              with_loop_barrier do
-                check_block(statement.body, scopes:, return_type:, allow_return: false)
-              end
-            else
-              validate_consuming_foreign_expression!(statement.expression, scopes:, root_allowed: true)
-              validate_hoistable_foreign_expression!(statement.expression, scopes:, root_hoistable: false)
-              infer_expression(statement.expression, scopes:)
+            with_loop_barrier do
+              check_block(statement.body, scopes:, return_type:, allow_return: false)
             end
           when AST::ExpressionStmt
             validate_consuming_foreign_expression!(statement.expression, scopes:, root_allowed: true)

data/lib/milk_tea/core/semantic_analyzer/type_compatibility.rb

@@ -187,9 +187,36 @@ module MilkTea
         return unless left_type.integer? && right_type.integer?
         return left_type if left_type == right_type
         return unless left_type.fixed_width_integer? && right_type.fixed_width_integer?
-        return unless left_type.signed_integer? == right_type.signed_integer?
 
-        left_type.integer_width >= right_type.integer_width ? left_type : right_type
+        # Same signedness: the wider type wins (both operands are losslessly
+        # assignable to it).
+        if left_type.signed_integer? == right_type.signed_integer?
+          return left_type.integer_width >= right_type.integer_width ? left_type : right_type
+        end
+
+        # Mixed signed/unsigned: promote to the narrowest signed type that holds
+        # both operands' full ranges, mirroring the lossless assignment rule. A
+        # strictly-wider signed type covers an unsigned operand; equal-width or
+        # wider unsigned operands widen to the next signed width. Mixing with a
+        # 64-bit unsigned type has no safe signed common type, so callers fall
+        # back to requiring an explicit cast.
+        signed_type, unsigned_type = if left_type.signed_integer?
+          [left_type, right_type]
+        else
+          [right_type, left_type]
+        end
+
+        return signed_type if signed_type.integer_width > unsigned_type.integer_width
+
+        signed_type_above_width(unsigned_type.integer_width)
+      end
+
+      def signed_type_above_width(width)
+        case width
+        when 8 then @ctx.types.fetch("short")
+        when 16 then @ctx.types.fetch("int")
+        when 32 then @ctx.types.fetch("long")
+        end
       end
 
       def wider_float_type(left_type, right_type)

data/lib/milk_tea/core/types.rb

@@ -850,9 +850,6 @@ module MilkTea
       end
 
       def field_c_name(name)
-        stripped = name.delete_suffix("_")
-        return stripped if stripped != name && MilkTea::KEYWORDS.key?(stripped)
-
         name
       end
 
@@ -961,9 +958,6 @@ module MilkTea
       end
 
       def field_c_name(name)
-        stripped = name.delete_suffix("_")
-        return stripped if stripped != name && MilkTea::KEYWORDS.key?(stripped)
-
         name
       end
 

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

@@ -484,8 +484,7 @@ module MilkTea
         when AST::UnsafeStmt
           stmt.body.each { |child| collect_indirect_import_uses_from_stmt(child, used, binding_resolution, import_module_names) }
         when AST::DeferStmt
-          collect_indirect_import_uses_from_expr(stmt.expression, used, binding_resolution, import_module_names) if stmt.expression
-          stmt.body&.each { |child| collect_indirect_import_uses_from_stmt(child, used, binding_resolution, import_module_names) }
+          stmt.body.each { |child| collect_indirect_import_uses_from_stmt(child, used, binding_resolution, import_module_names) }
         when AST::ReturnStmt
           collect_indirect_import_uses_from_expr(stmt.value, used, binding_resolution, import_module_names) if stmt.value
         when AST::ExpressionStmt
@@ -766,8 +765,7 @@ module MilkTea
         when AST::UnsafeStmt
           stmt.body.each { |s| collect_names_from_statement(s, used) }
         when AST::DeferStmt
-          collect_names_from_expr(stmt.expression, used) if stmt.expression
-          stmt.body&.each { |s| collect_names_from_statement(s, used) }
+          stmt.body.each { |s| collect_names_from_statement(s, used) }
         when AST::ReturnStmt
           collect_names_from_expr(stmt.value, used) if stmt.value
         when AST::ExpressionStmt

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