mt-lang 0.3.14 → 0.3.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12f7a371c9cb4162851cefb9277292455904b6e0bedcba05312770f00d724481
-  data.tar.gz: 4d73b7c4ef5c45abc731edbfd6e465067230b6772669ad8952a75247cd10e2ad
+  metadata.gz: b5cd3c1ef5e380b8d0c5d4e20f829400d01c6fdfd3e495e8c98050f4af8b59ba
+  data.tar.gz: 0e083d1780c9d591b996604a8b489726fa0f0c6fb85b8dc03da87b681383d5ca
 SHA512:
-  metadata.gz: d434a523bf7e5678512af400a5054765d62976778d27c1d647203fa03a39145509648d82d32d56d02218da1324d66717b1eb1da75543ea513e49fcc2e9fc5410
-  data.tar.gz: d2fa42eb284fd01df9492fa772d69c46853712862dd6f8d4f1f0f20aa8c40fc996abf821763175419cb58abb2ffe2da94a750e30b8c47d7b0c9ae9c31ec75f75
+  metadata.gz: 44f866e7d6bf6fc4998e0a9054bf898b27ed47ef38149de1881baf1d810e845b94e3d1f3ff304486654ea339329d726a10d969bcff4021943cc98b03bfe3fe01
+  data.tar.gz: 0fa7237c14aa9e038b4d51ae08a5971430d0e47b97fb19caf619aeb80a5e562de99aae1cf342a11ffea41e3b2268a128454bbf022b3e9182ddd94ff2ff0aff45

data/README.md

@@ -477,7 +477,7 @@ Rules:
 - Conditions must be `bool`.
 - There is no truthy or falsy coercion from integers or pointers.
 - `pass` is an explicit no-op statement for intentionally empty block bodies.
-- `if` supports an inline single-statement form: `if cond: stmt else: stmt`. The body is a single statement on the same line instead of an indented block.
+- Every block-taking statement accepts a `:`-newline-indented block, or a single statement on the same line after `:`. This applies to `if`/`else` (e.g. `if cond: stmt else: stmt`), `while`, `for`, `defer` (e.g. `defer: cleanup()`), and `unsafe`. `match` arms are the exception: their inline form is a single value expression.
 
 `match` supports the following scrutinee types:
 
@@ -615,7 +615,7 @@ Rules:
 
 `defer`:
 
-- `defer expr`
+- `defer: expr` — single-statement inline form
 - `defer:` block form
 - `return` is not allowed inside defer blocks.
 

data/docs/index.html

@@ -658,12 +658,12 @@ function main() -> int:
 
     ## Collections: Vec and Map (import std.hash for primitive keys)
     var entities = vec.Vec[Entity].create()
-    defer entities.release()
+    defer: entities.release()
     entities.push(Entity.create(1, EntityKind.player, "Hero"))
     entities.push(Entity.create(2, EntityKind.enemy, "Goblin"))
 
     var name_counts = map.Map[str, int].create()
-    defer name_counts.release()
+    defer: name_counts.release()
     name_counts.set("player", 1)
     name_counts.set("enemy", 5)
 
@@ -742,7 +742,7 @@ function main() -> int:
     io.print_line(f"Position: #{position.x:.2}, #{position.y:.2}")
     io.print_line(f"ID hex: #{player.entity.id:x}")
     var msg = fmt.format(f"Score: #{score}")
-    defer msg.release()
+    defer: msg.release()
 
     ## Heredoc string
     let help = <<-HELP
@@ -753,7 +753,7 @@ function main() -> int:
 
     ## Defer: cleanup at scope exit (lowers to C cleanup labels)
     let data: own[int] = heap.must_alloc[int](1)
-    defer heap.release[int](data)
+    defer: heap.release[int](data)
 
     ## Proc / closure
     let scale = make_scaler(2.5)
@@ -1598,11 +1598,11 @@ match record:
 <button class="copy-btn" onclick="copyCode(this)">Copy</button>
 <pre><code>function main() -> int:
     rl.init_window(800, 600, "Game")
-    defer rl.close_window()
+    defer: rl.close_window()
 
     while not rl.window_should_close():
         rl.begin_drawing()
-        defer rl.end_drawing()
+        defer: rl.end_drawing()
         render_frame()
 
     return 0</code></pre>
@@ -2149,8 +2149,8 @@ function attach(window: ref[Window]) -> Result[void, EventError]:
     let closed_sub = window.closed.subscribe(on_close)?
     let resized_sub = window.resized.subscribe(on_resize)?
 
-    defer window.closed.unsubscribe(closed_sub)
-    defer window.resized.unsubscribe(resized_sub)
+    defer: window.closed.unsubscribe(closed_sub)
+    defer: window.resized.unsubscribe(resized_sub)
 
     return Result[void, EventError].success()</code></pre>
 </div>

data/docs/language-design.md

@@ -119,7 +119,7 @@ extending Player:
 
 function main() -> int:
 	rl.init_window(screen_width, screen_height, "Milk Tea")
-	defer rl.close_window()
+	defer: rl.close_window()
 
 	var player = Player(
 		position = rl.Vector2(x = 400.0, y = 300.0),
@@ -132,7 +132,7 @@ function main() -> int:
 		player.update(dt)
 
 		rl.begin_drawing()
-		defer rl.end_drawing()
+		defer: rl.end_drawing()
 
 		rl.clear_background(rl.BLACK)
 		rl.draw_circle_v(player.position, player.radius, rl.GOLD)
@@ -423,16 +423,12 @@ Milk Tea should include a small number of control-flow features that materially
 
 #### `defer`
 
-`defer` registers cleanup code at scope exit and lowers to obvious cleanup labels in C.
+`defer` registers cleanup code at scope exit and lowers to obvious cleanup labels in C. Both forms use the block-header `:`:
 
 ```mt
-
-
 function load_texture(path: str) -> Result[Texture, LoadError]:
 	let texture = rl.load_texture(path)
-
-	if texture.id == 0:
-		return Result[Texture, LoadError].failure(error= LoadError.file_not_found)
+	defer: rl.unload_texture(texture)
 
 	return Result[Texture, LoadError].success(value= texture)
 ```

data/docs/language-manual.md

@@ -596,6 +596,8 @@ if x > 10: return "big" else if x > 5: return "med" else: return "small"
 
 The inline form supports all statement kinds in the body (`return`, `let`, `var`, `defer`, assignment, expression statement, etc.). Blocks and inline form may be mixed: any branch may use either form independently.
 
+Every block-taking statement follows the same rule: a `:` followed by a newline starts an indented block, while a `:` followed by anything else on the same line introduces exactly one inline statement. This applies uniformly to `if`/`else`, `while`, `for`, `defer`, and `unsafe` (§4.3, §4.4, §4.5). `match` arms are the exception: their inline form is a single value expression (§4.2).
+
 ### 4.2 Match
 
 Scrutinee types supported:
@@ -717,6 +719,13 @@ Single-form `for` supports:
 - `span[T]`
 - custom structural iterables with a non-editable zero-argument `iter()` method
 
+Every loop body accepts either a `:`-newline-indented block or a single statement on the same line as the header:
+
+```mt
+while ready: poll()
+for value in values: accumulate(value)
+```
+
 Iterator protocol for custom structural iterables:
 
 - the iterable value must expose `iter()` with no parameters
@@ -795,10 +804,10 @@ Rules:
 
 ### 4.4 Defer
 
-Forms:
+Both forms use the block-header `:` introduced in §4:
 
 ```mt
-defer cleanup()
+defer: cleanup()
 
 # or
 
@@ -807,7 +816,10 @@ defer:
     release_b()
 ```
 
-`return` is not allowed inside defer blocks.
+Rules:
+
+- `defer` always requires `:`. A single statement may follow on the same line (`defer: release_a()`), or a `:`-newline-indented block may hold several statements.
+- `return` is not allowed inside defer blocks.
 
 ### 4.5 Unsafe
 
@@ -1363,8 +1375,8 @@ function attach(window: ref[Window]) -> Result[void, EventError]:
     let closed_sub = window.closed.subscribe(on_close)?
     let resized_sub = window.resized.subscribe(on_resize)?
 
-    defer window.closed.unsubscribe(closed_sub)
-    defer window.resized.unsubscribe(resized_sub)
+    defer: window.closed.unsubscribe(closed_sub)
+    defer: window.resized.unsubscribe(resized_sub)
 
     return Result[void, EventError].success()
 ```

data/lib/milk_tea/base.rb

@@ -3,7 +3,7 @@
 require "pathname"
 
 module MilkTea
-  VERSION = "0.3.14"
+  VERSION = "0.3.16"
 
   def self.root
     @root ||= Pathname.new(File.expand_path("../..", __dir__))

data/lib/milk_tea/core/ast.rb

@@ -212,8 +212,8 @@ module MilkTea
     ReturnStmt = Data.define(:value, :line, :column, :length) do
       def initialize(value:, line: nil, column: nil, length: nil) = super
     end
-    DeferStmt = Data.define(:expression, :body, :line, :column, :length) do
-      def initialize(expression:, body:, line: nil, column: nil, length: nil) = super
+    DeferStmt = Data.define(:body, :line, :column, :length) do
+      def initialize(body:, line: nil, column: nil, length: nil) = super
     end
     ErrorBlockStmt = Data.define(:body, :line, :column, :length, :message, :header_type, :header_expression, :header_bindings, :header_iterables) do
       def initialize(body:, line: nil, column: nil, length: nil, message: nil, header_type: nil, header_expression: nil, header_bindings: nil, header_iterables: nil) = super

data/lib/milk_tea/core/control_flow/builder.rb

@@ -212,8 +212,8 @@ module MilkTea
         when AST::UnsafeStmt
           build_block(stmt.body, next_id, break_target:, continue_target:)
         when AST::DeferStmt
-          body_entry = stmt.body ? build_block(stmt.body, next_id, break_target:, continue_target:) : next_id
-          expression_reads, expression_reads_info = stmt.expression ? read_identifiers_with_sites(stmt.expression) : [Set.new, []]
+          body_entry = build_block(stmt.body, next_id, break_target:, continue_target:)
+          expression_reads, expression_reads_info = statement_list_reads_with_sites(stmt.body)
           defer_id = @graph.add_node(
             kind: :defer,
             statement: stmt,
@@ -315,6 +315,66 @@ module MilkTea
         [reads, reads_info]
       end
 
+      def statement_list_reads_with_sites(statements)
+        reads = Set.new
+        reads_info = []
+        statement_list_read_identifiers(statements, reads, reads_info)
+        [reads, reads_info]
+      end
+
+      def statement_list_read_identifiers(statements, reads, reads_info)
+        Array(statements).each do |statement|
+          statement_read_identifiers(statement, reads, reads_info)
+        end
+      end
+
+      def statement_read_identifiers(statement, reads, reads_info)
+        case statement
+        when AST::ExpressionStmt
+          read_identifiers(statement.expression, reads, reads_info)
+        when AST::DeferStmt
+          statement_list_read_identifiers(statement.body, reads, reads_info)
+        when AST::LocalDecl
+          read_identifiers(statement.value, reads, reads_info)
+          statement_list_read_identifiers(statement.else_body, reads, reads_info)
+        when AST::Assignment
+          read_identifiers(statement.target, reads, reads_info)
+          read_identifiers(statement.value, reads, reads_info)
+        when AST::ReturnStmt
+          read_identifiers(statement.value, reads, reads_info)
+        when AST::IfStmt
+          statement.branches.each do |branch|
+            read_identifiers(branch.condition, reads, reads_info)
+            statement_list_read_identifiers(branch.body, reads, reads_info)
+          end
+          statement_list_read_identifiers(statement.else_body, reads, reads_info)
+        when AST::WhileStmt
+          read_identifiers(statement.condition, reads, reads_info)
+          statement_list_read_identifiers(statement.body, reads, reads_info)
+        when AST::ForStmt
+          statement.iterables.each { |iterable| read_identifiers(iterable, reads, reads_info) }
+          statement_list_read_identifiers(statement.body, reads, reads_info)
+        when AST::UnsafeStmt
+          statement_list_read_identifiers(statement.body, reads, reads_info)
+        when AST::MatchStmt
+          read_identifiers(statement.expression, reads, reads_info)
+          statement.arms.each do |arm|
+            read_identifiers(arm.pattern, reads, reads_info)
+            statement_list_read_identifiers(arm.body, reads, reads_info)
+          end
+        when AST::StaticAssert
+          read_identifiers(statement.condition, reads, reads_info)
+          read_identifiers(statement.message, reads, reads_info)
+        when AST::WhenStmt
+          read_identifiers(statement.discriminant, reads, reads_info)
+          statement.branches.each do |branch|
+            read_identifiers(branch.pattern, reads, reads_info)
+            statement_list_read_identifiers(branch.body, reads, reads_info)
+          end
+          statement_list_read_identifiers(statement.else_body, reads, reads_info)
+        end
+      end
+
       def read_identifiers(expression, names = Set.new, reads_info = [])
         case expression
         when nil

data/lib/milk_tea/core/lowering/async/analysis.rb

@@ -145,15 +145,9 @@ module MilkTea
         when AST::UnsafeStmt
           await_counter = analyze_async_statements!(statement.body, await_counter, env, param_fields, local_fields, await_fields)
         when AST::DeferStmt
-          if statement.body
-            cleanup_env = duplicate_env(env)
-            cleanup_env[:return_context] = cleanup_env[:return_context]&.merge(allow_return: false)
-            await_counter = analyze_async_statements!(statement.body, await_counter, cleanup_env, param_fields, local_fields, await_fields)
-          end
-          if statement.expression.is_a?(AST::AwaitExpr)
-            await_fields[statement.expression.object_id] = build_async_await_field_info(statement.expression, await_counter, env:, param_fields:, local_fields:)
-            await_counter += 1
-          end
+          cleanup_env = duplicate_env(env)
+          cleanup_env[:return_context] = cleanup_env[:return_context]&.merge(allow_return: false)
+          await_counter = analyze_async_statements!(statement.body, await_counter, cleanup_env, param_fields, local_fields, await_fields)
         else
           nil
         end

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

@@ -194,7 +194,7 @@ module MilkTea
         when AST::UnsafeStmt
           statements_contain_await?(s.body, async_info)
         when AST::DeferStmt
-          (s.body && statements_contain_await?(s.body, async_info)) || (s.expression && async_expression_contains_await?(s.expression))
+          statements_contain_await?(s.body, async_info)
         else
           false
         end
@@ -1237,15 +1237,7 @@ module MilkTea
     end
 
     def lower_async_defer_cleanup(statement, env:, async_info:)
-      body = if statement.body
-                statement.body
-              elsif statement.expression
-                [AST::ExpressionStmt.new(expression: statement.expression, line: statement.line)]
-              else
-                []
-              end
-
-      { body:, env: snapshot_env(env) }
+      { body: statement.body, env: snapshot_env(env) }
     end
 
     def lower_async_cleanup_entries(local_defers, outer_defers, frame_expr:, raw_frame_expr:, async_info:)

data/lib/milk_tea/core/lowering/async/normalization.rb

@@ -154,13 +154,8 @@ module MilkTea
       when AST::DeferStmt
         cleanup_env = duplicate_env(env)
         cleanup_env[:return_context] = cleanup_env[:return_context]&.merge(allow_return: false)
-        cleanup_body = if statement.body
-                         normalize_async_statements(statement.body, counter, cleanup_env, return_type:)
-                       else
-                         expression_setup, expression = normalize_async_expression(statement.expression, counter, env: cleanup_env)
-                         expression_setup + [AST::ExpressionStmt.new(expression:, line: statement.line)]
-                       end
-        [AST::DeferStmt.new(expression: nil, body: cleanup_body, line: statement.line, column: statement.column, length: statement.length)]
+        cleanup_body = normalize_async_statements(statement.body, counter, cleanup_env, return_type:)
+        [AST::DeferStmt.new(body: cleanup_body, line: statement.line, column: statement.column, length: statement.length)]
       when AST::BreakStmt, AST::ContinueStmt, AST::StaticAssert, AST::PassStmt
         [statement]
       else

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

@@ -16,11 +16,7 @@ module MilkTea
       statements.each do |statement|
         case statement
         when AST::DeferStmt
-          local_defers << if statement.body
-            lower_defer_cleanup_body(statement.body, env: local_env, return_type:)
-          else
-            lower_defer_cleanup_expression(statement.expression, env: local_env)
-          end
+          local_defers << lower_defer_cleanup_body(statement.body, env: local_env, return_type:)
         when AST::UnsafeStmt
           lower_block_unsafe_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
         when AST::LocalDecl

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/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
@@ -1161,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/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