mt-lang 0.3.37 → 0.3.39

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

@@ -31,8 +31,10 @@ module MilkTea
         # Parse
         begin
           parse_start = total_start ? monotonic_time : nil
+          parse_errors = []
           ast = if path && File.file?(path)
                   parse_result = Parser.parse_collecting_errors(content, path: uri)
+                  parse_errors = parse_result.errors
                   parse_result.errors.each { |error| diagnostics << format_error(error) }
                   parse_result.ast
                 else
@@ -63,6 +65,10 @@ module MilkTea
             source_overrides: source_overrides,
             workspace_root_path: workspace_root_path,
             content: content,
+            # A file whose own parse recovered with errors can poison the loader's
+            # program-check cache and yield no facts on the standard path; skip the
+            # program check and resolve imports directly for those files.
+            skip_program_check: !parse_errors.empty?,
           )
           imports_ms = elapsed_ms(imports_start) if imports_start
           unresolved_import_paths = imported_modules.fetch(:unresolved_import_paths)
@@ -167,7 +173,7 @@ module MilkTea
 
       private
 
-      def self.resolve_imported_modules(uri, ast, diagnostics, resolution:, effective_platform:, shared_module_cache: nil, source_overrides: nil, workspace_root_path: nil, content: nil)
+      def self.resolve_imported_modules(uri, ast, diagnostics, resolution:, effective_platform:, shared_module_cache: nil, source_overrides: nil, workspace_root_path: nil, content: nil, skip_program_check: false)
         path = uri_to_path(uri)
          return { modules: {}, unresolved_import_paths: [], module_name: nil } unless path && File.file?(path)
 
@@ -186,10 +192,14 @@ module MilkTea
         # cached analysis and resolves correctly. If the program check fails
         # (e.g. missing module), fall through to the standard resolution
         # path so that prelude modules and regular errors are still reported.
-        begin
-          loader.check_program_collecting(path)
-        rescue ModuleLoadError, PackageLockError
-          # best-effort — standard path below handles diagnostics
+        # Skipped when the file's own parse recovered with errors: the program
+        # check poisons the loader cache and yields no facts on that path.
+        unless skip_program_check
+          begin
+            loader.check_program_collecting(path)
+          rescue ModuleLoadError, PackageLockError
+            # best-effort — standard path below handles diagnostics
+          end
         end
 
         resolution_result = loader.imported_modules_for_ast_collecting_errors(ast, importer_path: path)

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