mt-lang 0.3.37 → 0.3.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84f8e5a5913811a35cd5cd470c43f3827aee62bfe5b151add730d45fe341bee2
-  data.tar.gz: fd76e0d6f88abfe0fda004829430effc5b7030957754b6d3d3eebbd6739b96b5
+  metadata.gz: 952280dd2ad14bc3b5751fc7e8a3d29b39363293b1436cc1b3b546c31c938427
+  data.tar.gz: e0bdf3468681b07914143c32b0b9cc2470cdbeaf55cf81994186003dc406261b
 SHA512:
-  metadata.gz: cc533975db0511ab0f5ac62887ec101ebae699841d3cdbc5079faf1e2a0be877e1ceb71d56b3605ca7c37c60c43019fd3288e690325a21cf87806ca2cff138b5
-  data.tar.gz: 89d0efc35e9bfec7c1d9c5a612e2f136d3c6fd8f80259f88a657ac46be896ff79c43c0810f98eba8312139151c343c59205b2a3b5fd72af60d2de2fdfc0fd16a
+  metadata.gz: 9dcf6f6c955f1428b5374315782fda121669ae3c12a8c84d683205cb44bb4ca7903465e70447860e89c0753695f01af513903e93b82987838fa724be19fc7b2f
+  data.tar.gz: 67c259de17bdd81a4f5785d7dbe05cf39ab959ea51c1f27ed2b05a516ed97ce91a4b2291aa415e0abaa695337f1fc1825ead4acdfceb480a9be4db3cd3a24dd4

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/core/c_backend/reinterpret.rb

@@ -116,13 +116,13 @@ module MilkTea
         return false if expression.expression.type.is_a?(Types::Null)
 
         c_type(expression.target_type) == c_type(expression.expression.type)
-      rescue StandardError
+      rescue CBackendError
         false
       end
 
       def identity_reinterpret?(target_type, source_type)
         c_type(target_type) == c_type(source_type)
-      rescue StandardError
+      rescue CBackendError
         false
       end
 

data/lib/milk_tea/core/c_backend.rb

@@ -27,6 +27,18 @@ module MilkTea
     def code
       "backend/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
 
   class CBackend

data/lib/milk_tea/core/compile_time.rb

@@ -6,16 +6,27 @@ module MilkTea
   module CompileTime
     Layout = ::MilkTea::Types::Layout
 
-    class ReturnValue < StandardError
-      attr_reader :value
+    # Carries the value of a `return` statement out of the block evaluator as
+    # an ordinary value instead of an exception; callers unwrap it when present.
+    ReturnOutcome = Data.define(:value)
 
-      def initialize(value)
-        @value = value
-        super("return #{value.inspect}")
+    class Error < StandardError
+      def code
+        "compile_time/error"
       end
-    end
 
-    class Error < StandardError; end
+      def to_diagnostic(path: nil)
+        Diagnostic.new(
+          path: path,
+          line: nil,
+          column: nil,
+          length: nil,
+          code: code,
+          message: message,
+          severity: :error,
+        )
+      end
+    end
 
     def self.evaluate(expression, resolve_identifier:, resolve_member_access:, resolve_type_ref: nil, resolve_call: nil)
       Evaluator.new(
@@ -249,7 +260,10 @@ module MilkTea
         result = nil
 
         statements.each do |statement|
-          result = evaluate_statement(statement, scopes:)
+          outcome = evaluate_statement(statement, scopes:)
+          return outcome if outcome.is_a?(ReturnOutcome)
+
+          result = outcome
         end
 
         result
@@ -261,7 +275,7 @@ module MilkTea
           evaluate_local_decl(statement, scopes:)
         when AST::ReturnStmt
           value = statement.value ? evaluate_expression(statement.value, scopes:) : nil
-          raise ReturnValue.new(value)
+          ReturnOutcome.new(value)
         when AST::WhileStmt
           evaluate_while(statement, scopes:)
         when AST::ForStmt
@@ -276,6 +290,7 @@ module MilkTea
           evaluate_expression(statement.expression, scopes:)
         when AST::PassStmt, AST::BreakStmt, AST::ContinueStmt
           # no-op at compile time
+          nil
         when AST::EmitStmt
           # emitted declarations are collected during lowering
           nil
@@ -354,7 +369,10 @@ module MilkTea
           break unless condition
           break unless CompileTime.boolean_value?(condition)
 
-          statement.body.each { |body_stmt| evaluate_statement(body_stmt, scopes:) }
+          statement.body.each do |body_stmt|
+            outcome = evaluate_statement(body_stmt, scopes:)
+            return outcome if outcome.is_a?(ReturnOutcome)
+          end
           iterations += 1
         end
 
@@ -372,7 +390,10 @@ module MilkTea
 
         iterable.each do |element|
           @variables[loop_var_name] = element
-          statement.body.each { |body_stmt| evaluate_statement(body_stmt, scopes:) }
+          statement.body.each do |body_stmt|
+            outcome = evaluate_statement(body_stmt, scopes:)
+            return outcome if outcome.is_a?(ReturnOutcome)
+          end
         end
 
         result
@@ -382,13 +403,19 @@ module MilkTea
         statement.branches.each do |branch|
           condition = evaluate_expression(branch.condition, scopes:)
           if CompileTime.boolean_value?(condition) && condition
-            branch.body.each { |body_stmt| evaluate_statement(body_stmt, scopes:) }
+            branch.body.each do |body_stmt|
+              outcome = evaluate_statement(body_stmt, scopes:)
+              return outcome if outcome.is_a?(ReturnOutcome)
+            end
             return condition
           end
         end
 
         if statement.else_body
-          statement.else_body.each { |body_stmt| evaluate_statement(body_stmt, scopes:) }
+          statement.else_body.each do |body_stmt|
+            outcome = evaluate_statement(body_stmt, scopes:)
+            return outcome if outcome.is_a?(ReturnOutcome)
+          end
         end
 
         nil
@@ -401,7 +428,10 @@ module MilkTea
         statement.arms.each do |arm|
           wildcard = arm.pattern.is_a?(AST::Identifier) && arm.pattern.name == "_"
           if wildcard || CompileTime.equality_result(scrutinee, evaluate_expression(arm.pattern, scopes:)) == true
-            arm.body.each { |body_stmt| evaluate_statement(body_stmt, scopes:) }
+            arm.body.each do |body_stmt|
+              outcome = evaluate_statement(body_stmt, scopes:)
+              return outcome if outcome.is_a?(ReturnOutcome)
+            end
             return scrutinee
           end
         end
@@ -451,9 +481,8 @@ module MilkTea
             initial_vars[param.name] = arg_value
           end
           ctx = BlockContext.new(@checker, initial_variables: initial_vars)
-          ctx.evaluate_block(func.ast.body, scopes:)
-        rescue ReturnValue => e
-          e.value
+          result = ctx.evaluate_block(func.ast.body, scopes:)
+          result.is_a?(ReturnOutcome) ? result.value : result
         end
       end
 

data/lib/milk_tea/core/lexer.rb

@@ -26,6 +26,18 @@ module MilkTea
     def code
       "lex/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 Lexer

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

@@ -1850,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.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.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/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 = {}
 

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

@@ -34,17 +34,17 @@ module MilkTea
                   end
                   record_local_completion_snapshot(end_line, 1_000_000, nested_scopes)
                 rescue SemanticError => e
-                  if @collecting_errors
-                    @structural_errors << e
-                    next
+                  if e.line.nil? && statement.line
+                    e = SemanticError.new(
+                      e.message,
+                      line: statement.line,
+                      column: source_column(statement),
+                      length: source_length(statement),
+                      path: @path,
+                    )
                   end
-
-                  raise e unless e.line.nil?
-
-                  stmt_line = statement.line
-                  raise e if stmt_line.nil?
-
-                  raise_sema_error(e.message, statement)
+                  @structural_errors << e
+                  next
                 end
               end
             end

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

@@ -18,7 +18,8 @@ module MilkTea
                 collect_structural_error(e)
               end
             when AST::VarDecl
-              binding = @ctx.top_level_values.fetch(decl.name)
+              binding = @ctx.top_level_values[decl.name]
+              next unless binding
               if decl.value
                 validate_consuming_foreign_expression!(decl.value, scopes: [], root_allowed: false)
                 validate_hoistable_foreign_expression!(decl.value, scopes: [], root_hoistable: false)
@@ -39,7 +40,8 @@ module MilkTea
       end
 
       def check_expr_const(decl)
-        binding = @ctx.top_level_values.fetch(decl.name)
+        binding = @ctx.top_level_values[decl.name]
+        return unless binding
         validate_consuming_foreign_expression!(decl.value, scopes: [], root_allowed: false)
         validate_hoistable_foreign_expression!(decl.value, scopes: [], root_hoistable: false)
 
@@ -270,9 +272,7 @@ module MilkTea
       def evaluate_compile_time_block(statements, scopes: nil)
         ctx = CompileTime::BlockContext.new(self)
         result = ctx.evaluate_block(statements, scopes:)
-        result
-      rescue CompileTime::ReturnValue => e
-        e.value
+        result.is_a?(CompileTime::ReturnOutcome) ? result.value : result
       rescue CompileTime::Error => e
         raise_sema_error(e.message)
       end
@@ -558,9 +558,8 @@ module MilkTea
         end
 
         ctx = CompileTime::BlockContext.new(self, 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
       rescue CompileTime::Error => e
         raise_sema_error(e.message)
       end
@@ -589,9 +588,8 @@ module MilkTea
         end
 
         ctx = CompileTime::BlockContext.new(self, 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
       rescue CompileTime::Error => e
         raise_sema_error(e.message)
       end

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

@@ -293,9 +293,15 @@ module MilkTea
 
             constraints = resolve_type_param_constraints(decl.type_params)
             if decl.is_a?(AST::InterfaceDecl)
-              @ctx.interfaces[decl.name] = @ctx.interfaces.fetch(decl.name).with(type_param_constraints: constraints)
+              interface_binding = @ctx.interfaces[decl.name]
+              next unless interface_binding
+
+              @ctx.interfaces[decl.name] = interface_binding.with(type_param_constraints: constraints)
             else
-              @ctx.types.fetch(decl.name).define_type_param_constraints(constraints)
+              type_binding = @ctx.types[decl.name]
+              next unless type_binding
+
+              type_binding.define_type_param_constraints(constraints)
             end
           end
         end
@@ -455,7 +461,8 @@ module MilkTea
           with_error_node(decl) do
             next unless decl.is_a?(AST::StructDecl) || decl.is_a?(AST::UnionDecl)
 
-            struct_type = @ctx.types.fetch(decl.name)
+            struct_type = @ctx.types[decl.name]
+            next unless struct_type
             struct_type.ast_declaration = decl if struct_type.respond_to?(:ast_declaration=)
             type_params = if struct_type.is_a?(Types::GenericStructDefinition)
               seen = {}
@@ -581,7 +588,8 @@ module MilkTea
           with_error_node(decl) do
             next unless decl.is_a?(AST::EnumDecl) || decl.is_a?(AST::FlagsDecl)
 
-            enum_type = @ctx.types.fetch(decl.name)
+            enum_type = @ctx.types[decl.name]
+            next unless enum_type
             backing_type = resolve_type_ref(decl.backing_type)
             unless backing_type.is_a?(Types::Primitive) && backing_type.integer?
               raise_sema_error("#{decl.name} backing type must be an integer primitive, got #{backing_type}")
@@ -641,7 +649,8 @@ module MilkTea
           with_error_node(decl) do
             next unless decl.is_a?(AST::VariantDecl)
 
-            variant_type = @ctx.types.fetch(decl.name)
+            variant_type = @ctx.types[decl.name]
+            next unless variant_type
             type_params = if variant_type.is_a?(Types::GenericVariantDefinition)
               seen = {}
               variant_type.type_params.each_with_object({}) do |name, params|

data/lib/milk_tea/core/semantic_analyzer.rb

@@ -187,31 +187,9 @@ module MilkTea
       end
 
       def check
-        @completed_phases = Set.new
-
-        run_phase(:install_builtin_types)
-        run_phase(:install_builtin_attributes)
-        run_phase(:install_imports)
-        run_phase(:install_prelude_types, requires: [:install_imports])
-        run_phase(:declare_named_types, requires: [:install_builtin_types, :install_imports, :install_prelude_types])
-        run_phase(:resolve_generic_type_param_constraints, requires: [:declare_named_types])
-        run_phase(:resolve_type_aliases, requires: [:declare_named_types])
-        run_phase(:declare_attributes)
-        run_phase(:predeclare_top_level_consts)
-        run_phase(:resolve_aggregate_fields, requires: [:resolve_type_aliases, :declare_named_types])
-        run_phase(:resolve_enum_members, requires: [:declare_named_types])
-        run_phase(:resolve_variant_arms, requires: [:declare_named_types])
-        run_phase(:collect_emit_declarations)
-        run_phase(:declare_top_level_values, requires: [:resolve_aggregate_fields, :resolve_type_aliases])
-        run_phase(:check_attribute_applications, requires: [:declare_attributes])
-        run_phase(:declare_functions, requires: [:resolve_aggregate_fields, :resolve_enum_members, :resolve_variant_arms])
-        run_phase(:check_interface_conformances, requires: [:declare_functions, :resolve_aggregate_fields])
-        run_phase(:check_top_level_values, requires: [:declare_top_level_values])
-        run_phase(:finalize_top_level_const_values, requires: [:check_top_level_values])
-        run_phase(:check_top_level_static_asserts, requires: [:finalize_top_level_const_values])
-        run_phase(:check_functions, requires: [:declare_functions, :resolve_aggregate_fields, :check_interface_conformances])
-
-        build_analysis
+        result = check_collecting_errors
+        raise result[:errors].first unless result[:errors].empty?
+        result[:analysis]
       end
 
       def run_phase(name, requires: [])
@@ -291,12 +269,11 @@ module MilkTea
         end
       end
 
-      # Like check, but collects per-function errors instead of raising at first.
-      # Structural phases (imports, type resolution, declaration) collect errors per
-      # declaration so that the maximum number of diagnostics are surfaced.
+      # Runs all sema phases and collects every error instead of stopping at
+      # the first one.  Structural phases collect per-declaration, and
+      # function-body phases collect per function/method.
       # Returns { analysis: Analysis, errors: [SemanticError] }.
       def check_collecting_errors
-        @collecting_errors = true
         @structural_errors = []
         @completed_phases = Set.new
 
@@ -353,8 +330,6 @@ module MilkTea
       end
 
       def collect_structural_error(error)
-        raise error unless @collecting_errors
-
         @structural_errors << error
       end
     end

data/lib/milk_tea/lsp/server/code_actions.rb

@@ -404,6 +404,12 @@ module MilkTea
         end
 
         def handle_workspace_diagnostic(params)
+          progress = nil
+          if (work_done_token = params['workDoneToken'])
+            progress = create_progress_handle(@protocol, work_done_token)
+            progress.report(percentage: 0, message: 'Collecting workspace diagnostics...')
+          end
+
           previous_ids = params['previousResultIds'] || []
           prev_map = previous_ids.each_with_object({}) do |entry, h|
             h[entry['uri']] = entry['value'] if entry.is_a?(Hash) && entry['uri']
@@ -420,15 +426,19 @@ module MilkTea
 
             cached = @workspace_diagnostic_cache[uri]
             if cached && cached[:result_id] == prev_map[uri] && cached[:fingerprint] == fingerprint
-              { uri: uri, kind: 'unchanged', resultId: result_id, items: [] }
+              { uri: uri, kind: 'unchanged', resultId: result_id, items: [], version: nil }
             else
               @workspace_diagnostic_cache[uri] = { result_id: result_id, fingerprint: fingerprint }
-              { uri: uri, kind: 'full', resultId: result_id, items: diagnostics }
+              { uri: uri, kind: 'full', resultId: result_id, items: diagnostics, version: nil }
             end
           end
 
+          progress&.report(percentage: 100, message: "#{items.length} document#{items.length == 1 ? '' : 's'} checked")
+          progress&.done(message: 'Workspace diagnostics ready')
+
           { items: items }
         rescue StandardError => e
+          progress&.done(message: 'Workspace diagnostics failed')
           warn "Error in workspace/diagnostic handler: #{e.message}"
           { items: [] }
         end

data/lib/milk_tea/lsp/server/formatting.rb

@@ -16,7 +16,8 @@ module MilkTea
           # Enrich with hierarchical children from AST
           ast = @workspace.get_ast(uri)
           if ast && result
-            enrich_with_children(result, ast)
+            facts = @workspace.get_facts(uri)
+            enrich_with_children(result, ast, facts)
           end
 
           module_name = resolve_outline_module_name(uri)
@@ -74,17 +75,42 @@ module MilkTea
           children
         end
 
-        def enrich_with_children(symbols, ast)
+        def enrich_with_children(symbols, ast, facts)
           removed_local_names = []
           removed_method_names = []
           removed_nested_type_names = []
           removed_event_names = []
           name_index = symbols.each_with_object(Hash.new { |h, k| h[k] = [] }) { |s, h| h[s[:name]] << s }
 
-          ast.declarations&.each do |decl|
+          flatten_module_declarations(ast.declarations).each do |decl|
             removed_nested_type_names.concat(collect_nested_type_names(decl)) if decl.is_a?(AST::StructDecl)
 
             case decl
+            when AST::VarDecl
+              parent = name_index[decl.name]&.find { |s| symbol_line(s) == (decl.line || 0) }
+              next unless parent
+
+              detail = decl.type ? type_detail_string(decl.type) : nil
+              detail ||= resolved_local_type_detail(decl, facts)
+              parent[:detail] = detail if detail
+
+            when AST::TypeAliasDecl
+              parent = name_index[decl.name]&.find { |s| symbol_line(s) == (decl.line || 0) }
+              next unless parent
+
+              if (detail = type_detail_string(decl.target))
+                parent[:detail] = "= #{detail}"
+              end
+
+            when AST::ExternFunctionDecl, AST::ForeignFunctionDecl
+              parent = name_index[decl.name]&.find { |s| symbol_line(s) == (decl.line || 0) }
+              next unless parent
+
+              detail_parts = []
+              detail_parts << 'async' if decl.respond_to?(:async) && decl.async
+              detail_parts << "-> #{type_detail_string(decl.return_type) || 'void'}"
+              parent[:detail] = detail_parts.join(' ')
+
             when AST::EventDecl
               parent = name_index[decl.name]&.find { |s| symbol_line(s) == (decl.line || 0) }
               next unless parent
@@ -100,26 +126,11 @@ module MilkTea
               detail_parts = []
               detail_parts << 'const' if decl.respond_to?(:const) && decl.const
               detail_parts << 'async' if decl.respond_to?(:async) && decl.async
-              if (ret = type_detail_string(decl.return_type))
-                detail_parts << "-> #{ret}"
-              end
-              parent[:detail] = detail_parts.join(' ') unless detail_parts.empty?
+              detail_parts << "-> #{type_detail_string(decl.return_type) || 'void'}"
+              parent[:detail] = detail_parts.join(' ')
 
               locals = collect_local_decls(decl.body)
-              next unless locals&.any?
-
-              parent[:children] ||= []
-              parent_children = parent[:children]
-              locals.each do |local|
-                next unless local.name
-
-                child = local_decl_symbol(local)
-                next unless child
-
-                parent_children << child unless parent_children.any? { |pc| pc[:name] == child[:name] }
-                removed_local_names << local.name
-                removed_local_names.concat(descendant_names(child))
-              end
+              append_local_children(parent, locals, facts, removed_local_names)
             when AST::ExtendingBlock
               type_name_str = decl.type_name.name.parts.join('.')
 
@@ -153,20 +164,7 @@ module MilkTea
                 removed_method_names << child[:name] if child[:kind] == 6
 
                 locals = collect_local_decls(method.respond_to?(:body) ? method.body : nil)
-                next unless locals&.any?
-
-                child[:children] ||= []
-                child_children = child[:children]
-                locals.each do |local|
-                  next unless local.name
-
-                  local_child = local_decl_symbol(local)
-                  next unless local_child
-
-                  child_children << local_child unless child_children.any? { |pc| pc[:name] == local_child[:name] }
-                  removed_local_names << local.name
-                  removed_local_names.concat(descendant_names(local_child))
-                end
+                append_local_children(child, locals, facts, removed_local_names)
               end
             when AST::ConstDecl
               parent = name_index[decl.name]&.find { |s| symbol_line(s) == (decl.line || 0) }
@@ -179,25 +177,13 @@ module MilkTea
               next unless decl.block_body
 
               locals = collect_local_decls(decl.block_body)
-              next unless locals&.any?
-
-              parent[:children] ||= []
-              parent_children = parent[:children]
-              locals.each do |local|
-                next unless local.name
-
-                child = local_decl_symbol(local)
-                next unless child
-
-                parent_children << child unless parent_children.any? { |pc| pc[:name] == child[:name] }
-                removed_local_names << local.name
-                removed_local_names.concat(descendant_names(child))
-              end
+              append_local_children(parent, locals, facts, removed_local_names)
             else
               parent_name = child_parent_name(decl)
               parent = parent_name ? name_index[parent_name]&.find { |s| symbol_line(s) == (decl.line || 0) } : nil
               next unless parent
 
+              detail_parts = []
               if decl.is_a?(AST::StructDecl) && decl.implements&.any?
                 ifaces = decl.implements.map { |i|
                   base = i.respond_to?(:parts) ? i.parts.join('.') : i.name.parts.join('.')
@@ -210,9 +196,19 @@ module MilkTea
                         end
                   "#{base}#{args}"
                 }.join(', ')
-                parent[:detail] = "(#{ifaces})"
+                detail_parts << "(#{ifaces})"
+              end
+
+              if decl.respond_to?(:backing_type) && decl.backing_type && (bt = type_detail_string(decl.backing_type))
+                detail_parts << ": #{bt}"
+              end
+
+              if (generic = generic_signature_detail(decl))
+                detail_parts << generic
               end
 
+              parent[:detail] = detail_parts.join(' ') unless detail_parts.empty?
+
               type_params = expand_generic_type_params(decl)
               if type_params&.any?
                 parent[:children] ||= []
@@ -374,14 +370,78 @@ module MilkTea
           line = (a.line) ? a.line : default_line
           return nil unless a.respond_to?(:name) && a.name && line
           col = a.column ? a.column : 1
+
+          detail = nil
+          if a.respond_to?(:fields) && a.fields&.any?
+            fields = a.fields.map { |f| "#{f.name}: #{type_detail_string(f.type)}" }.join(', ')
+            detail = "(#{fields})"
+          end
+
           {
             name: a.name, kind: 22,
+            detail: detail,
             range: { start: { line: line - 1, character: 0 }, end: { line: line, character: 0 } },
             selectionRange: {
               start: { line: line - 1, character: col - 1 },
               end: { line: line - 1, character: col - 1 + a.name.length },
             },
-          }
+          }.compact
+        end
+
+        # Renders the generic parameter clause of a type declaration, e.g.
+        # `[A, B]` for `struct Pair[A, B]` or `[@a]` for `struct Buffer[@a]`.
+        def generic_signature_detail(decl)
+          parts = []
+          if decl.respond_to?(:lifetime_params) && decl.lifetime_params&.any?
+            parts.concat(decl.lifetime_params.map(&:to_s))
+          end
+          if decl.respond_to?(:type_params) && decl.type_params&.any?
+            parts.concat(decl.type_params.map { |tp| tp.respond_to?(:name) ? tp.name : tp.to_s })
+          end
+          parts.empty? ? nil : "[#{parts.join(', ')}]"
+        end
+
+        # Module-level `when` branches are compile-time conditionals; the token
+        # symbol scan lists their declarations, so flatten the branch bodies so
+        # the enrichment below can type them like ordinary top-level decls.
+        def flatten_module_declarations(declarations)
+          (declarations || []).flat_map do |decl|
+            if decl.is_a?(AST::WhenStmt)
+              (decl.branches || []).flat_map { |b| flatten_module_declarations(b.body) } +
+                flatten_module_declarations(decl.else_body)
+            else
+              [decl]
+            end
+          end
+        end
+
+        # Adds local declaration children to an outline symbol. Destructure
+        # locals (`let Vec2(x, y) = ...`) introduce a spurious flat variable
+        # symbol named after the destructure type; that symbol is collected for
+        # removal instead of being shown as a typed child.
+        def append_local_children(container, locals, facts, removed_local_names)
+          return unless locals&.any?
+
+          container[:children] ||= []
+          children = container[:children]
+          locals.each do |local|
+            if local.respond_to?(:destructure_bindings) && local.destructure_bindings
+              type_name = local.destructure_type_name
+              if type_name
+                name = type_name.is_a?(Array) ? type_name.join('.') : type_name.to_s
+                removed_local_names << name unless removed_local_names.include?(name)
+              end
+              next
+            end
+            next unless local.name
+
+            child = local_decl_symbol(local, facts:)
+            next unless child
+
+            children << child unless children.any? { |pc| pc[:name] == child[:name] }
+            removed_local_names << local.name
+            removed_local_names.concat(descendant_names(child))
+          end
         end
 
         def collect_local_decls(body)
@@ -417,7 +477,7 @@ module MilkTea
           end
         end
 
-        def local_decl_symbol(decl)
+        def local_decl_symbol(decl, facts: nil)
           return nil unless decl.name
           return nil if decl.name == '_'
 
@@ -429,8 +489,9 @@ module MilkTea
           if decl.respond_to?(:value) && decl.value.is_a?(AST::ProcExpr)
             detail ||= proc_signature_detail(decl.value)
             proc_locals = collect_local_decls(decl.value.body)
-            children = proc_locals.filter_map { |l| local_decl_symbol(l) }
+            children = proc_locals.filter_map { |l| local_decl_symbol(l, facts:) }
           end
+          detail ||= resolved_local_type_detail(decl, facts)
 
           {
             name: decl.name, kind: 13,
@@ -441,6 +502,60 @@ module MilkTea
           }.compact
         end
 
+        # Resolves the declared type of an inferred local from semantic facts.
+        # Prefers the sema binding type (which reflects let/var ... else: and
+        # other flow refinement), falling back to the initializer expression
+        # type recorded during checking. Returns nil when facts are unavailable
+        # or the binding is missing.
+        def resolved_local_type_detail(decl, facts)
+          return nil unless facts
+          return nil unless facts.respond_to?(:binding_resolution) && facts.binding_resolution
+
+          binding_id = facts.binding_resolution.declaration_binding_ids[decl.object_id]
+          if binding_id
+            type = facts.binding_resolution.binding_types[binding_id]
+            return nil if type.is_a?(Types::Error)
+            return short_type_detail(type) if type
+          end
+
+          return nil unless decl.respond_to?(:value) && decl.value
+          return nil unless facts.respond_to?(:resolved_expr_types)
+
+          node_id = facts.respond_to?(:ast) && facts.ast ? facts.ast.node_ids[decl.value.object_id] : nil
+          return nil unless node_id
+
+          type = facts.resolved_expr_types[node_id]
+          return nil if type.is_a?(Types::Error)
+
+          short_type_detail(type)
+        end
+
+        # Renders a resolved semantic type for outline display without module
+        # qualifiers (e.g. std.deque.Deque[int] as Deque[int]). Falls back to
+        # the canonical #to_s when a type has no usable short form.
+        def short_type_detail(type)
+          return nil unless type
+
+          case type
+          when Types::Nullable
+            "#{short_type_detail(type.base)}?"
+          when Types::Span
+            "span[#{short_type_detail(type.element_type)}]"
+          when Types::SoA
+            "SoA[#{short_type_detail(type.element_type)}, #{type.count}]"
+          when Types::StructInstance, Types::VariantInstance, Types::GenericInstance
+            args = type.arguments.map { |arg| short_type_arg(arg) }.join(', ')
+            args.empty? ? type.name : "#{type.name}[#{args}]"
+          else
+            name = type.respond_to?(:name) ? type.name.to_s : ''
+            name.empty? ? type.to_s : name
+          end
+        end
+
+        def short_type_arg(arg)
+          arg.is_a?(Types::LiteralTypeArg) ? arg.value.to_s : short_type_detail(arg)
+        end
+
         def descendant_names(symbol)
           return [] unless symbol[:children]
 
@@ -487,9 +602,7 @@ module MilkTea
           detail_parts << 'mut' if m.respond_to?(:kind) && m.kind == :editable_function
           detail_parts << 'static' if m.respond_to?(:kind) && m.kind == :static_function
           detail_parts << 'async' if m.respond_to?(:async) && m.async
-          if (ret = type_detail_string(m.return_type))
-            detail_parts << "-> #{ret}"
-          end
+          detail_parts << "-> #{type_detail_string(m.return_type) || 'void'}"
           {
             name: m.name, kind: 6,
             range: { start: { line: m.line - 1, character: 0 }, end: { line: (m.respond_to?(:end_line) && m.end_line ? m.end_line : m.line), character: 0 } },
@@ -507,10 +620,11 @@ module MilkTea
           case type
           when AST::TypeRef
             type.to_s
-          when AST::ProcType
+          when AST::FunctionType, AST::ProcType
             params = (type.params || []).map { |p| type_detail_string(p.type) }.join(', ')
             ret = type_detail_string(type.return_type) || 'void'
-            "proc(#{params}) -> #{ret}"
+            keyword = type.is_a?(AST::FunctionType) ? 'fn' : 'proc'
+            "#{keyword}(#{params}) -> #{ret}"
           when AST::TupleType
             base = "(#{(type.element_types || []).map { |t| type_detail_string(t) }.join(', ')})"
             type.nullable ? "#{base}?" : base

data/lib/milk_tea/lsp/server/inlay_hints.rb

@@ -108,13 +108,11 @@ module MilkTea
         def collect_inferred_type_hints(facts, start_line, start_char, end_line, end_char)
           hints = []
           collect_local_decls(facts.ast).each do |decl|
+            next unless decl.name && decl.name != '_'
             next unless decl.type.nil?
             next unless position_in_range?(decl.line - 1, decl.column - 1, start_line, start_char, end_line, end_char)
 
-            binding = facts.values[decl.name]
-            next unless binding
-
-            display_type = describe_type_for_hint(binding.storage_type)
+            display_type = resolved_decl_type_detail(decl, facts)
             next unless display_type
 
             hints << {
@@ -127,20 +125,30 @@ module MilkTea
           hints
         end
 
+        # Resolves the declared type of an inferred local from semantic facts so
+        # the hint reflects flow refinement (let/var ... else:, ?-propagation).
+        def resolved_decl_type_detail(decl, facts)
+          resolution = facts.respond_to?(:binding_resolution) ? facts.binding_resolution : nil
+          return nil unless resolution
+
+          binding_id = resolution.declaration_binding_ids[decl.object_id]
+          return nil unless binding_id
+
+          type = resolution.binding_types[binding_id]
+          return nil if type.is_a?(Types::Error)
+
+          short_type_detail(type)
+        end
+
         def collect_inferred_return_hints(facts, start_line, start_char, end_line, end_char)
           hints = []
           collect_function_defs(facts.ast).each do |func|
             next unless func.return_type.nil?
             next unless position_in_range?(func.line - 1, func.column - 1, start_line, start_char, end_line, end_char)
 
-            binding = facts.functions[func.name]
-            unless binding
-              facts.imports.each_value do |mod|
-                binding = mod.functions[func.name]
-                break if binding
-              end
-            end
+            binding = resolve_function_binding(facts, func)
             next unless binding
+            next unless binding.respond_to?(:type) && binding.type.respond_to?(:return_type)
 
             return_type = binding.type.return_type
             next unless return_type
@@ -160,6 +168,20 @@ module MilkTea
           hints
         end
 
+        def resolve_function_binding(facts, func)
+          name = func.name
+          if func.is_a?(AST::MethodDef)
+            facts.methods.each_value do |methods|
+              binding = methods[name] || methods["static:#{name}"]
+              return binding if binding
+            end
+            return nil
+          end
+
+          facts.functions[name] ||
+            facts.imports.each_value.find { |mod| mod.functions.key?(name) }&.functions&.dig(name)
+        end
+
         def collect_local_decls(ast_node)
           results = []
           case ast_node

data/lib/milk_tea/lsp/server/selection_range.rb

@@ -24,7 +24,7 @@ module MilkTea
           line_str = lines[lsp_line] || ""
           return nil if line_str.empty?
 
-          token_range = token_bounds_at(line_str, lsp_char)
+          token_range = token_bounds_at(line_str, lsp_line, lsp_char)
           line_range = { start: { line: lsp_line, character: 0 },
                          end: { line: lsp_line, character: line_str.length } }
 
@@ -47,7 +47,7 @@ module MilkTea
           current
         end
 
-        def token_bounds_at(line_str, lsp_char)
+        def token_bounds_at(line_str, lsp_line, lsp_char)
           col = [lsp_char, line_str.length - 1].min
           col = [col, 0].max
 
@@ -61,8 +61,8 @@ module MilkTea
           return nil if left == right && line_str[left] !~ /[A-Za-z0-9_]/
 
           {
-            start: { line: 0, character: left },
-            end: { line: 0, character: right + 1 },
+            start: { line: lsp_line, character: left },
+            end: { line: lsp_line, character: right + 1 },
           }
         end
 

data/lib/milk_tea/lsp/server/semantic_tokens.rb

@@ -18,7 +18,7 @@ module MilkTea
             short_uri = shorten_uri(uri) || uri
             log_perf_breakdown('textDocument/semanticTokens/full', elapsed,
                               "uri=#{short_uri} bytes=#{content.bytesize} lines=#{content.count("\n") + 1} cache=hit data_len=#{cached[:data].length}")
-            return { data: cached[:data] }
+            return { resultId: cached[:result_id], data: cached[:data] }
           end
 
           tokens_start = monotonic_time
@@ -37,9 +37,8 @@ module MilkTea
           data = encode_semantic_tokens(semantic_entries)
           encode_ms = elapsed_ms(encode_start)
 
-          @semantic_tokens_cache[uri] = { content_hash: cache_key, data: data }
-
           result_id = next_semantic_token_result_id(uri)
+          @semantic_tokens_cache[uri] = { content_hash: cache_key, data: data, result_id: result_id }
           @semantic_tokens_delta_cache[uri] = {
             result_id: result_id,
             content_hash: cache_key,
@@ -51,7 +50,7 @@ module MilkTea
           log_perf_breakdown('textDocument/semanticTokens/full', elapsed,
                             "uri=#{short_uri} bytes=#{content.bytesize} lines=#{content.count("\n") + 1} cache=miss tokens=#{tokens.length} entries=#{semantic_entries.length} data_len=#{data.length} facts=on stages_ms=tokens:#{tokens_ms},facts:#{facts_ms},build:#{build_ms},encode:#{encode_ms}")
 
-          { data: data }
+          { resultId: result_id, data: data }
         rescue StandardError => e
           warn "Error in semanticTokens/full handler: #{e.message}"
           { data: [] }
@@ -1745,7 +1744,12 @@ module MilkTea
 
           start_offset = prefix * 5
           delete_count = old_mid * 5
-          insert_tokens = encode_semantic_tokens(new_entries[prefix...(new_entries.length - suffix)])
+
+          # The inserted segment must keep the relative encoding against the
+          # last unchanged token preceding the edit, so encode the full token
+          # stream from the document origin and slice out the middle segment.
+          full_encoded = encode_semantic_tokens(new_entries)
+          insert_tokens = full_encoded[start_offset...(new_entries.length - suffix) * 5]
 
           [{ start: start_offset, deleteCount: delete_count, data: insert_tokens }]
         end

data/lib/milk_tea/lsp/server/type_hierarchy.rb

@@ -5,11 +5,11 @@ module MilkTea
     class Server
       module ServerTypeHierarchy
         TYPE_KIND_MAP = {
-          struct: 22,
-          enum: 13,
-          flags: 13,
-          variant: 13,
-          union: 22,
+          struct: 23,
+          enum: 10,
+          flags: 10,
+          variant: 23,
+          union: 23,
           interface: 11,
         }.freeze
 

data/lib/milk_tea/packages/manifest.rb

@@ -42,6 +42,15 @@ module MilkTea
       new(path).load
     end
 
+    # Best-effort manifest load for optional lookups: returns nil when no
+    # manifest applies to the path or when the manifest is invalid, instead
+    # of raising PackageManifestError.
+    def self.load_option(path)
+      load(path)
+    rescue PackageManifestError
+      nil
+    end
+
     def self.manifest_exists_for?(path)
       path = File.expand_path(path)
       current = File.directory?(path) ? path : File.dirname(path)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.3.37
+  version: 0.3.38
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -624,7 +624,7 @@ metadata:
   homepage_uri: https://teefan.github.io/mt-lang/
   source_code_uri: https://github.com/teefan/mt-lang
 post_install_message: |
-  Milk Tea 0.3.37 installed!
+  Milk Tea 0.3.38 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH
@@ -646,7 +646,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.18
 specification_version: 4
 summary: The Milk Tea programming language compiler toolchain
 test_files: []