mt-lang 0.3.34 → 0.3.38

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

@@ -186,6 +186,7 @@ module MilkTea
             mutable: false,
             pointer: false,
             const_value: element,
+            substitute_const_value: true,
           )
           emit_stmts, other_stmts = statement.body.partition { |s| s.is_a?(AST::EmitStmt) }
           emit_stmts.each do |emit_stmt|
@@ -486,13 +487,11 @@ module MilkTea
           expected_type: return_type,
           contextual_int_to_float: contextual_int_to_float_target?(return_type),
         ) : nil
-        if prepared_cleanups.any? && cstr_trackable_type?(return_type)
-          raise LoweringError.new("formatted string temporaries cannot be returned as borrowed text; use std.fmt.format(f\"...\") when ownership must escape",
-            line: statement.line, column: statement.column, path: @ctx.current_analysis_path)
-        end
-
         prepared_cleanup_list = prepared_cleanups.flat_map(&:itself)
-        if prepared_cleanup_list.any? && return_type.is_a?(Types::Struct) && struct_contains_string_field?(return_type)
+        if prepared_cleanup_list.any? && (cstr_trackable_type?(return_type) ||
+                                          (return_type.is_a?(Types::Struct) && struct_contains_string_field?(return_type)))
+          # A dynamic f-string temp owns its heap buffer; returning it transfers
+          # ownership to the caller, so the format release must not run.
           prepared_cleanup_list = prepared_cleanup_list.reject { |stmt| stmt.is_a?(IR::ExpressionStmt) && stmt.expression.is_a?(IR::Call) && stmt.expression.callee == "mt_format_str_release" }
         end
         cleanup = prepared_cleanup_list + cleanup_statements(local_defers, active_defers)
@@ -793,7 +792,7 @@ module MilkTea
             else_body: nil,
           )
         end
-        local_defers.concat(prepared_cleanups)
+        local_defers.concat(reject_format_releases_for_assignment(prepared_cleanups, storage_type))
         if contains_proc_storage_type?(storage_type)
           local_value = IR::Name.new(name: linkage_name, type: storage_type, pointer: false)
           local_defers << lower_proc_nullable_release_statements(local_value, storage_type)

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

@@ -23,6 +23,7 @@ module MilkTea
         expanded_declarations.grep(AST::ConstDecl).filter_map do |decl|
           type = @ctx.values.fetch(decl.name).type
           const_value = @ctx.values.fetch(decl.name).const_value
+          ensure_registered_storage_type_types(type)
 
           next if type == Types::BUILTIN_TYPE_META_TYPE
 
@@ -35,7 +36,7 @@ module MilkTea
               value = lower_const_value_literal(type, const_value)
             end
           elsif decl.block_body || decl.value.is_a?(AST::ExpressionList)
-            raise LoweringError.new("constant #{decl.name} has no compile-time value", line: decl.line, column: decl.column)
+            raise LoweringError.new("constant #{decl.name} has no compile-time value", line: decl.line, column: decl.column, path: @ctx.current_analysis_path)
           else
             value = lower_static_storage_initializer(decl.value, env: empty_env, expected_type: type)
             if (decl.value.is_a?(AST::Call) || decl.value.is_a?(AST::Specialization)) && static_initializer_ir_has_call?(value)
@@ -78,6 +79,43 @@ module MilkTea
         end
       end
 
+      ## Register C struct typedefs for every tuple type reachable from a
+      ## module-storage type (consts and globals).  `ensure_tuple_struct` is
+      ## normally called while lowering tuple *expressions*, so a tuple that
+      ## only appears in static storage never gets its `mt_tuple_...` typedef
+      ## emitted; the C compiler then fails with "unknown type name".
+      def ensure_registered_storage_type_types(type, seen = {})
+        return if type.nil? || seen[type]
+
+        seen[type] = true
+        if type.is_a?(Types::Tuple)
+          ensure_tuple_struct(type)
+          type.element_types.each { |element_type| ensure_registered_storage_type_types(element_type, seen) }
+        end
+
+        case type
+        when Types::Nullable
+          ensure_registered_storage_type_types(type.base, seen)
+        when Types::Span
+          ensure_registered_storage_type_types(type.element_type, seen)
+        when Types::Task
+          ensure_registered_storage_type_types(type.result_type, seen)
+        when Types::GenericInstance, Types::StructInstance, Types::VariantInstance
+          type.arguments.each do |argument|
+            ensure_registered_storage_type_types(argument, seen) unless argument.is_a?(Types::LiteralTypeArg)
+          end
+        end
+
+        if type.respond_to?(:fields) && type.fields
+          type.fields.each_value { |field_type| ensure_registered_storage_type_types(field_type, seen) }
+        end
+        if type.respond_to?(:arms)
+          type.arms.each_value do |arm_fields|
+            arm_fields.each_value { |field_type| ensure_registered_storage_type_types(field_type, seen) }
+          end
+        end
+      end
+
       def lower_const_value_literal(type, const_value)
         case const_value
         when Integer
@@ -130,6 +168,7 @@ module MilkTea
           next unless decl.is_a?(AST::VarDecl) || decl.is_a?(AST::EventDecl)
 
           type = @ctx.values.fetch(decl.name).type
+          ensure_registered_storage_type_types(type)
           ensure_event_runtime(type) if type.is_a?(Types::Event)
           value = if decl.is_a?(AST::VarDecl) && decl.value
             lower_static_storage_initializer(decl.value, env: empty_env, expected_type: type)

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

@@ -643,6 +643,8 @@ module MilkTea
               end
             end
 
+            written_scalar_captures = captures.select { |c| written_names.include?(c.name) && !array_capture_names.include?(c.name) }
+
             @artifacts.synthetic_structs << IR::StructDecl.new(
               name: cap_struct_c_name, linkage_name: cap_struct_c_name,
               fields: cap_fields, packed: false, alignment: nil,
@@ -674,6 +676,14 @@ module MilkTea
 
             rewritten_body = array_capture_names.empty? ? block_body : rewrite_pfor_array_captures(block_body, array_capture_names)
             worker_body.concat(rewritten_body)
+
+            written_scalar_captures.each do |c|
+              worker_body << IR::Assignment.new(
+                target: IR::Member.new(receiver: cap_name_ir, member: c.name, type: c.type),
+                operator: "=",
+                value: IR::Name.new(name: c.name, type: c.type, pointer: false),
+              )
+            end
           end
 
           @artifacts.synthetic_functions << IR::Function.new(
@@ -715,7 +725,7 @@ module MilkTea
                         )
                       end
 
-          { worker_c_name:, cap_local_name:, cap_struct_type:, cap_init:, capture_names: Set.new(captures.map(&:name)), written_names:, captureless: }
+          { worker_c_name:, cap_local_name:, cap_struct_type:, cap_init:, capture_names: Set.new(captures.map(&:name)), written_names:, written_scalar_captures: captureless ? [] : written_scalar_captures, captureless: }
         end
 
         validate_pfor_write_conflicts!(block_infos)
@@ -768,6 +778,20 @@ module MilkTea
           type: void_type,
         ))
 
+        block_infos.each do |info|
+          info[:written_scalar_captures].each do |c|
+            call_site << IR::Assignment.new(
+              target: IR::Name.new(name: c.name, type: c.type, pointer: false),
+              operator: "=",
+              value: IR::Member.new(
+                receiver: IR::Name.new(name: info[:cap_local_name], type: info[:cap_struct_type], pointer: false),
+                member: c.name,
+                type: c.type,
+              ),
+            )
+          end
+        end
+
         IR::BlockStmt.new(body: call_site)
       end
 

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

@@ -745,7 +745,7 @@ module MilkTea
           end
             return function_type_for_name(expression.name) if @ctx.functions.key?(expression.name)
 
-            raise LoweringError.new("unknown identifier #{expression.name}", line: expression.line, column: expression.column)
+            raise LoweringError.new("unknown identifier #{expression.name}", line: expression.line, column: expression.column, path: @ctx.current_analysis_path)
         when AST::MemberAccess
           if (type_expr = resolve_type_expression(expression.receiver))
             member_type = resolve_type_member(type_expr, expression.member)
@@ -784,7 +784,7 @@ module MilkTea
           end
 
           return receiver_type.field(expression.member) if receiver_type.respond_to?(:field)
-          raise LoweringError.new("unknown member #{expression.member}", line: expression.line, column: expression.column)
+          raise LoweringError.new("unknown member #{expression.member}", line: expression.line, column: expression.column, path: @ctx.current_analysis_path)
         when AST::IndexAccess
           receiver_type = infer_expression_type(expression.receiver, env:)
           index_type = infer_expression_type(expression.index, env:)
@@ -1677,7 +1677,15 @@ module MilkTea
             evaluate_attribute_arg_call(expression.arguments, env:)
           else
             callee_name = expression.callee.callee.is_a?(AST::Identifier) ? expression.callee.callee.name : nil
-            if callee_name
+            if callee_name == "array"
+              values = []
+              expression.arguments.each do |argument|
+                val = compile_time_const_value(argument.value, env:)
+                return nil unless val
+                values << val
+              end
+              values
+            elsif callee_name
               func = @ctx.functions[callee_name]
               if func&.ast&.respond_to?(:const) && func.ast.const
                 evaluate_const_function_body_lower(func, expression.arguments)
@@ -1842,9 +1850,8 @@ module MilkTea
 
         evaluator = ConstFnLowerEvaluator.new(self)
         ctx = CompileTime::BlockContext.new(evaluator, initial_variables: initial_vars)
-        ctx.evaluate_block(func.ast.body, scopes: nil)
-      rescue CompileTime::ReturnValue => e
-        e.value
+        result = ctx.evaluate_block(func.ast.body, scopes: nil)
+        result.is_a?(CompileTime::ReturnOutcome) ? result.value : result
       end
 
       class ConstFnLowerEvaluator

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

@@ -459,8 +459,8 @@ module MilkTea
         end
       end
 
-      def local_binding(type:, linkage_name:, mutable:, pointer:, storage_type: nil, projection: nil, cstr_backed: false, cstr_list_backed: false, const_value: nil)
-        { type:, storage_type: storage_type || type, linkage_name:, mutable:, pointer:, projection:, cstr_backed:, cstr_list_backed:, const_value: }
+      def local_binding(type:, linkage_name:, mutable:, pointer:, storage_type: nil, projection: nil, cstr_backed: false, cstr_list_backed: false, const_value: nil, substitute_const_value: false)
+        { type:, storage_type: storage_type || type, linkage_name:, mutable:, pointer:, projection:, cstr_backed:, cstr_list_backed:, const_value:, substitute_const_value: }
       end
 
       def callable_type?(type)
@@ -904,6 +904,10 @@ module MilkTea
         visible_type = binding[:type]
         projection = binding[:projection]
 
+        if binding[:substitute_const_value] && !binding[:const_value].nil?
+          return lower_const_value_literal(visible_type, binding[:const_value])
+        end
+
         if projection == :result_success_value
           local_ref = IR::Name.new(name: binding[:linkage_name], type: storage_type, pointer: binding[:pointer])
           return variant_binding_projection_expression(local_ref, storage_type, "success", "value", visible_type)

data/lib/milk_tea/core/lowering.rb

@@ -59,6 +59,18 @@ module MilkTea
     def code
       "lowering/internal"
     end
+
+    def to_diagnostic(path: nil)
+      Diagnostic.new(
+        path: @path || path,
+        line: @line,
+        column: @column,
+        length: nil,
+        code: code,
+        message: message,
+        severity: :error,
+      )
+    end
   end
 
   module Lowering

data/lib/milk_tea/core/module_loader.rb

@@ -14,6 +14,18 @@ module MilkTea
     def code
       "module/error"
     end
+
+    def to_diagnostic(path: nil)
+      Diagnostic.new(
+        path: @path || path,
+        line: @line,
+        column: @column,
+        length: nil,
+        code: code,
+        message: message,
+        severity: :error,
+      )
+    end
   end
 
   class ModuleLoader
@@ -69,11 +81,10 @@ module MilkTea
       suffix_platform = platform_suffix_for_path(path)
       return suffix_platform if suffix_platform
 
-      manifest_platform = PackageManifest.load(path).platform
+      manifest = PackageManifest.load_option(path)
+      manifest_platform = manifest&.platform
       return manifest_platform if manifest_platform
 
-      normalize_platform_name(host_platform || default_host_platform)
-    rescue PackageManifestError
       normalize_platform_name(host_platform || default_host_platform)
     end
 
@@ -167,7 +178,10 @@ module MilkTea
 
     def check_program(path)
       with_check_context(path) do |root_path|
-        check_program_parallel(root_path)
+        errors = []
+        check_program_parallel(root_path, collecting_errors: errors)
+        raise errors.first if errors.any?
+
         build_program(root_path)
       end
     end
@@ -313,7 +327,7 @@ module MilkTea
         check_path(resolved_path)
       rescue SemanticError => e
         @analysis_cache[resolved_path] = previous if previous
-        collecting_errors << e if collecting_errors
+        collecting_errors << e
       end
       @forward_bindings.clear
 
@@ -322,13 +336,14 @@ module MilkTea
       # are not themselves part of a cycle; they just depended on cycle members.
       (levels + [tail_members]).each do |level_paths|
         if level_paths.length == 1
-          check_path(level_paths.first)
+          begin
+            check_path(level_paths.first)
+          rescue SemanticError => e
+            collecting_errors << e
+          end
         elsif level_paths.any?
-          check_level_parallel(level_paths)
+          collecting_errors.concat(check_level_parallel(level_paths))
         end
-      rescue SemanticError => e
-        raise unless collecting_errors
-        collecting_errors << e
       end
     end
 
@@ -369,28 +384,31 @@ module MilkTea
       levels
     end
 
+    # Checks a level of independent modules on worker threads. Each worker
+    # returns { ok: analysis } or { error: e } as an ordinary value; the join
+    # point collects the failed outcomes instead of re-raising them, so the
+    # caller decides whether to propagate or accumulate.
     def check_level_parallel(paths)
-      threads = paths.map do |resolved_path|
+      workers = paths.map do |resolved_path|
         Thread.new do
-          Thread.current[:resolved_path] = resolved_path
           begin
-            analysis = check_path(resolved_path)
-            Thread.current[:analysis] = analysis
+            { ok: check_path(resolved_path) }
           rescue ModuleLoadError, PackageLockError, SemanticError => e
-            Thread.current[:error] = e
+            { error: e }
           end
         end
       end
 
-      threads.each(&:join)
+      workers.each(&:join)
 
-      paths.zip(threads).each do |resolved_path, t|
-        raise t[:error] if t[:error]
-      end
+      workers.map(&:value).filter_map { |result| result[:error] }
     end
 
     def imported_modules_for_ast(ast, importer_path: nil)
-      resolve_imports_for_ast(ast, importer_path:, collecting: false)
+      result = resolve_imports_for_ast(ast, importer_path:, collecting: false)
+      raise result.errors.first.error if result.errors.any?
+
+      result.modules
     end
 
     def imported_modules_for_ast_collecting_errors(ast, importer_path: nil)
@@ -421,29 +439,27 @@ module MilkTea
             modules[import.path.to_s] = @binder.module_binding(import_analysis)
           end
         rescue ModuleLoadError, PackageLockError, SemanticError => e
-          raise unless collecting
-
-          handle_circular_import_in_collecting_mode(import, import_path, modules, errors, e)
+          if collecting
+            handle_circular_import_in_collecting_mode(import, import_path, modules, errors, e)
+          else
+            errors << ImportResolutionError.new(import:, error: e)
+          end
         end
       end
 
       begin
         @async_runtime_installer.install_async_runtime_dependency!(ast, modules, importer_path:, collecting_errors: collecting)
       rescue ModuleLoadError, PackageLockError => e
-        raise unless collecting
         errors << ImportResolutionError.new(import: nil, error: e)
       end
 
       begin
         @prelude_installer.install_prelude_modules!(ast, modules, importer_path:, collecting_errors: collecting)
       rescue ModuleLoadError, PackageLockError => e
-        raise unless collecting
         errors << ImportResolutionError.new(import: nil, error: e)
       end
 
-      return ImportResolution.new(modules: modules.freeze, errors: errors.freeze) if collecting
-
-      modules.freeze
+      ImportResolution.new(modules: modules.freeze, errors: errors.freeze)
     ensure
       @import_resolve_depth -= 1 if @import_resolve_depth
     end
@@ -528,7 +544,7 @@ module MilkTea
       if use_shared_cache?
         entry = @shared_cache[resolved_path]
         if entry
-          mtime = File.mtime(resolved_path).to_f rescue nil
+          mtime = source_mtime(resolved_path)
           if mtime && entry[:mtime] == mtime
             @analysis_cache[resolved_path] = entry[:analysis]
             return [resolved_path, nil, entry[:analysis]]
@@ -540,10 +556,19 @@ module MilkTea
       [resolved_path, ast, nil]
     end
 
+    # Option-style source modification time: nil when the file's mtime cannot
+    # be read (e.g. the file was removed between resolution and stat), so
+    # shared-cache reads simply miss instead of raising.
+    def source_mtime(path)
+      File.mtime(path).to_f
+    rescue SystemCallError
+      nil
+    end
+
     def update_shared_cache(resolved_path, analysis)
       return unless use_shared_cache?
 
-      mtime = File.mtime(resolved_path).to_f rescue nil
+      mtime = source_mtime(resolved_path)
       @shared_cache[resolved_path] = { mtime:, analysis: } if mtime
     end
 
@@ -575,11 +600,7 @@ module MilkTea
     end
 
     def inferred_module_name_for_path(path)
-      manifest = begin
-        PackageManifest.load(path)
-      rescue PackageManifestError
-        nil
-      end
+      manifest = PackageManifest.load_option(path)
 
       if manifest && path_within_root?(path, manifest.source_root)
         return module_name_for_path(path, manifest.source_root)
@@ -632,8 +653,9 @@ module MilkTea
       import_result = resolve_imports_for_ast(ast, importer_path: resolved_path, collecting: true)
       result = SemanticAnalyzer.check_collecting_errors(ast, imported_modules: import_result.modules, path: resolved_path)
       @analysis_cache[resolved_path] = result[:analysis] if result[:analysis]
-    rescue StandardError
-      # Analysis capture is best-effort.
+    rescue ModuleLoadError, PackageLockError, SemanticError
+      # Analysis capture is best-effort; named load/check failures leave the
+      # cycle member to the pass-2 re-check instead.
     ensure
       @checking_paths.pop
     end

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

@@ -297,7 +297,7 @@ module MilkTea
         expression = nil
         arms = []
         expression = parse_expression
-        arms = parse_match_arms(arms)
+        arms = normalize_mixed_match_arms(parse_match_arms(arms))
         if arms.first&.is_a?(AST::MatchExprArm)
           expr = AST::MatchExpr.new(expression:, arms:, line:, column: token.column, length: token.lexeme.length)
           AST::ExpressionStmt.new(expression: expr, line:)
@@ -311,12 +311,13 @@ module MilkTea
         recovered_arms = synchronize_to_match_arm_boundary
         target_line = line
         if recovered_arms
+          combined_arms = normalize_mixed_match_arms(arms + recovered_arms)
           stmt =
-            if recovered_arms.first&.is_a?(AST::MatchExprArm)
-              expr = AST::MatchExpr.new(expression: expression || recovery_error_expr(e), arms: arms + recovered_arms, line: target_line, column: token.column, length: token.lexeme.length)
+            if combined_arms.first&.is_a?(AST::MatchExprArm)
+              expr = AST::MatchExpr.new(expression: expression || recovery_error_expr(e), arms: combined_arms, line: target_line, column: token.column, length: token.lexeme.length)
               AST::ExpressionStmt.new(expression: expr, line: target_line)
             else
-              AST::MatchStmt.new(expression: expression || recovery_error_expr(e), arms: arms + recovered_arms, line: target_line, column: token.column, length: token.lexeme.length)
+              AST::MatchStmt.new(expression: expression || recovery_error_expr(e), arms: combined_arms, line: target_line, column: token.column, length: token.lexeme.length)
             end
           return stmt
         end
@@ -335,6 +336,33 @@ module MilkTea
         arms
       end
 
+      ## A statement match may mix inline value arms (`pattern: expr`) with
+      ## block arms.  The inline form is a single expression statement, so when
+      ## any arm is a block the inline arms are rewritten to block arms with a
+      ## single expression-statement body.  This keeps MatchStmt arms
+      ## homogeneous (all MatchArm) and MatchExpr arms homogeneous (all
+      ## MatchExprArm); the sema / control-flow / lowering consumers rely on
+      ## that invariant.
+      def normalize_mixed_match_arms(arms)
+        return arms unless arms.any? { |arm| arm.is_a?(AST::MatchExprArm) } && arms.any? { |arm| arm.is_a?(AST::MatchArm) }
+
+        arms.map do |arm|
+          if arm.is_a?(AST::MatchExprArm)
+            AST::MatchArm.new(
+              pattern: arm.pattern,
+              binding_name: arm.binding_name,
+              binding_line: arm.binding_line,
+              binding_column: arm.binding_column,
+              body: [AST::ExpressionStmt.new(expression: arm.value, line: arm.line)],
+              line: arm.line,
+              column: arm.column,
+            )
+          else
+            arm
+          end
+        end
+      end
+
       def parse_match_arm_body(arms = [])
         skip_newlines
         until check(:dedent) || eof?
@@ -652,7 +680,7 @@ module MilkTea
         token = previous
         line = token.line
         discriminant = parse_expression
-        branches = parse_match_arms([])
+        branches = normalize_mixed_match_arms(parse_match_arms([]))
         else_body = if check(:else)
           if check_next(:newline) || check_next(:indent)
             parse_else_branch_body
@@ -734,14 +762,14 @@ module MilkTea
         line = token.line
         arms = []
         expression = parse_expression
-        arms = parse_match_arms(arms)
+        arms = normalize_mixed_match_arms(parse_match_arms(arms))
         AST::MatchStmt.new(expression:, arms:, inline: true, line:, column: token.column, length: token.lexeme.length)
       rescue ParseError => e
         raise unless @recovery_errors
 
         @recovery_errors << e
         recovered_arms = synchronize_to_match_arm_boundary
-        return AST::MatchStmt.new(expression: expression || recovery_error_expr(e), arms: arms + recovered_arms, inline: true, line:, column: token.column, length: token.lexeme.length) if recovered_arms
+        return AST::MatchStmt.new(expression: expression || recovery_error_expr(e), arms: normalize_mixed_match_arms(arms + recovered_arms), inline: true, line:, column: token.column, length: token.lexeme.length) if recovered_arms
 
         recovery_error_stmt(e)
       end

data/lib/milk_tea/core/parser.rb

@@ -31,6 +31,18 @@ module MilkTea
     def code
       "parse/error"
     end
+
+    def to_diagnostic(path: nil)
+      Diagnostic.new(
+        path: @path || path,
+        line: line,
+        column: column,
+        length: nil,
+        code: code,
+        message: message,
+        severity: :error,
+      )
+    end
   end
 
   class SyntaxTokenStream

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

@@ -211,7 +211,8 @@ module MilkTea
         when IR::NullableSpanIndex
           "nullable_span_index<#{expression.receiver_type}>(#{render_expression(expression.receiver)}, #{render_expression(expression.index)})"
         when IR::Call
-          wrap("#{expression.callee}(#{expression.arguments.map { |argument| render_expression(argument) }.join(', ')})", parent_precedence, POSTFIX_PRECEDENCE)
+          callee_text = expression.callee.is_a?(String) ? expression.callee : render_expression(expression.callee)
+          wrap("#{callee_text}(#{expression.arguments.map { |argument| render_expression(argument) }.join(', ')})", parent_precedence, POSTFIX_PRECEDENCE)
         when IR::Unary
           operand = render_expression(expression.operand, UNARY_PRECEDENCE)
           text = expression.operator == "not" ? "not #{operand}" : "#{expression.operator}#{operand}"
@@ -258,6 +259,8 @@ module MilkTea
           end
         when IR::ArrayLiteral
           "#{expression.type}(#{expression.elements.map { |element| render_expression(element) }.join(', ')})"
+        when IR::SimdLaneWith
+          "#{render_expression(expression.src)}.with(#{render_expression(expression.index)}, #{render_expression(expression.value)})"
         when IR::Assignment
           "#{render_expression(expression.target)} #{expression.operator} #{render_expression(expression.value)}"
         else

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

@@ -9,7 +9,8 @@ module MilkTea
             case decl
             when AST::StructDecl
               packed, alignment = check_decl_attribute_applications!(decl.attributes, target_kind: :struct, target_label: "struct #{decl.name}", target_node: decl)
-              @ctx.types.fetch(decl.name).set_layout(packed:, alignment:)
+              struct_type = @ctx.types[decl.name]
+              struct_type.set_layout(packed:, alignment:) if struct_type
 
               decl.fields.each do |field|
                 with_error_node(field) do

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

@@ -249,32 +249,20 @@ module MilkTea
         end
       end
 
-      def check_functions
-        @ctx.top_level_functions.each_value do |binding|
-          check_function(binding)
-        end
-
-        @ctx.methods.each_value do |method_map|
-          method_map.each_value do |binding|
-            check_function(binding)
-          end
-        end
-      end
-
       # Validates the body of a specialized (instantiated) function or method
-      # binding.  The owner checker may be in collecting-errors mode, which
-      # would silently swallow body errors into @structural_errors.  We
-      # temporarily disable collect mode on the owner so the caller receives
-      # the SemanticError directly.
+      # binding.  The owner checker always accumulates body errors into its
+      # structural buffer, so this pulls out the new errors and surfaces the
+      # first non-tolerated one directly; tolerated ones are dropped.
       def validate_specialized_function_body!(binding)
         owner = binding.owner
-        prev_collecting = owner.instance_variable_get(:@collecting_errors)
-        owner.instance_variable_set(:@collecting_errors, false)
+        structural_errors = owner.instance_variable_get(:@structural_errors)
+        prev_count = structural_errors.length
         owner.check_function(binding)
+        new_errors = structural_errors[prev_count..].to_a
+        structural_errors.slice!(prev_count..) unless new_errors.empty?
+        new_errors.each { |error| raise error unless error.message.include?("cannot assign through immutable") }
       rescue SemanticError => e
         raise unless e.message.include?("cannot assign through immutable")
-      ensure
-        owner.instance_variable_set(:@collecting_errors, prev_collecting) if owner
       end
 
       # Per-function error collection used by check_collecting_errors.

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

@@ -9,7 +9,8 @@ module MilkTea
             next unless decl.is_a?(AST::StructDecl) || decl.is_a?(AST::OpaqueDecl)
             next if decl.implements.empty?
 
-            receiver_type = @ctx.types.fetch(decl.name)
+            receiver_type = @ctx.types[decl.name]
+            next unless receiver_type
             resolved_interfaces = []
             seen = {}