mt-lang 0.3.14 → 0.3.17

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/lowering.rb

@@ -31,7 +31,7 @@ require_relative "lowering/functions"
 require_relative "lowering/async/analysis"
 require_relative "lowering/async/normalization"
 require_relative "lowering/async/lowering"
-require_relative "lowering/async"
+require_relative "lowering/async/frame_builder"
 require_relative "lowering/block"
 require_relative "lowering/proc"
 require_relative "lowering/loops"
@@ -85,11 +85,27 @@ module MilkTea
   OrderResolution = Data.define(:target_type, :binding, :callee_name)
 
   class Lowerer
-    include CompatibilityHelpers
+    include Intrinsics
 
     attr_accessor :bypass_sema_type_cache
     attr_reader :recorded_expr_types
 
+    include LowererScans
+    include LowererDeclarations
+    include LowererEvents
+    include LowererFunctions
+    include LowererAsync
+    include LowererBlock
+    include LowererProc
+    include LowererLoops
+    include LowererExpressions
+    include LowererCalls
+    include LowererForeignCstr
+    include LowererStrBuffer
+    include LowererResolve
+    include LowererDyn
+    include LowererUtils
+
     def initialize(program)
       @program = program
       @ctx = ModuleContext.new
@@ -358,21 +374,5 @@ module MilkTea
       ordered.concat(modules.values - ordered)
       ordered
     end
-
-    include LowererScans
-    include LowererDeclarations
-    include LowererEvents
-    include LowererFunctions
-    include LowererAsync
-    include LowererBlock
-    include LowererProc
-    include LowererLoops
-    include LowererExpressions
-    include LowererCalls
-    include LowererForeignCstr
-    include LowererStrBuffer
-    include LowererResolve
-    include LowererDyn
-    include LowererUtils
   end
 end

data/lib/milk_tea/core/module_loader.rb

@@ -1,13 +1,24 @@
 # frozen_string_literal: true
 
-require_relative "module_loader/errors"
-require_relative "module_path_resolver"
-require_relative "module_binder"
-require_relative "async_runtime_installer"
-require_relative "prelude_installer"
-
 module MilkTea
+  class ModuleLoadError < StandardError
+    attr_reader :path, :line, :column
+
+    def initialize(message, path:, line: nil, column: nil)
+      @path = path
+      @line = line
+      @column = column
+      super("#{message}: #{path}")
+    end
+
+    def code
+      "module/error"
+    end
+  end
+
   class ModuleLoader
+    ImportResolution = Data.define(:modules, :errors)
+    ImportResolutionError = Data.define(:import, :error)
     Program = Data.define(:root_path, :root_analysis, :analyses_by_path, :analyses_by_module_name)
     PLATFORM_SUFFIXES = {
       "linux" => :linux,
@@ -90,6 +101,15 @@ module MilkTea
       MilkTea.host_platform
     end
 
+    def self.raise_platform_conflict!(path, pinned_platform, active_platform, error_class: nil)
+      if error_class == ModuleLoadError
+        raise ModuleLoadError.new("source file targets platform #{pinned_platform}; active platform is #{active_platform}", path:)
+      end
+
+      message = "source file #{path} targets platform #{pinned_platform}; active platform is #{active_platform}"
+      raise(error_class || ArgumentError, message)
+    end
+
     def initialize(module_roots: [MilkTea.root], package_graph: nil, shared_cache: nil, source_overrides: nil, platform: nil)
       @module_roots = module_roots.map { |root| File.expand_path(root.to_s) }
       @ast_cache = {}
@@ -380,15 +400,6 @@ module MilkTea
       @collecting_path_errors
     end
 
-    def self.raise_platform_conflict!(path, pinned_platform, active_platform, error_class: nil)
-      if error_class == ModuleLoadError
-        raise ModuleLoadError.new("source file targets platform #{pinned_platform}; active platform is #{active_platform}", path:)
-      end
-
-      message = "source file #{path} targets platform #{pinned_platform}; active platform is #{active_platform}"
-      raise(error_class || ArgumentError, message)
-    end
-
     def check_path(path)
       resolved_path, ast, cached = check_module_cache(path)
       return cached if cached

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/parser.rb

@@ -155,6 +155,23 @@ module MilkTea
       next_token.nil? || %i[newline eof].include?(next_token.type)
     end
 
+    def advance
+      @current += 1 unless eof?
+      previous
+    end
+
+    def eof?
+      peek.type == :eof
+    end
+
+    def peek
+      @tokens[@current]
+    end
+
+    def previous
+      @tokens[@current - 1]
+    end
+
     def match(*types)
       return false unless types.any? { |type| check(type) }
 
@@ -219,23 +236,6 @@ module MilkTea
       true
     end
 
-    def advance
-      @current += 1 unless eof?
-      previous
-    end
-
-    def eof?
-      peek.type == :eof
-    end
-
-    def peek
-      @tokens[@current]
-    end
-
-    def previous
-      @tokens[@current - 1]
-    end
-
     def error(token, message)
       ParseError.new(message, token:, path: @path)
     end

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.rb

@@ -129,7 +129,7 @@ module MilkTea
     end
 
     class Checker
-      include CompatibilityHelpers
+      include Intrinsics
 
       attr_reader :ctx
 

data/lib/milk_tea/core.rb

@@ -10,11 +10,15 @@ require_relative "core/cst"
 require_relative "core/cst_builder"
 require_relative "core/ast"
 require_relative "core/types"
-require_relative "core/binding_types"
+require_relative "core/bindings"
 require_relative "core/compile_time"
-require_relative "core/compatibility_helpers"
+require_relative "core/intrinsics"
 require_relative "core/parser"
 require_relative "core/module_roots"
+require_relative "core/module_path_resolver"
+require_relative "core/module_binder"
+require_relative "core/async_runtime_installer"
+require_relative "core/prelude_installer"
 require_relative "core/module_loader"
 require_relative "core/semantic_analyzer"
 require_relative "core/ir"