mt-lang 0.3.38 → 0.3.40

data/lib/milk_tea/core/types/predicates.rb

@@ -650,6 +650,63 @@ module MilkTea
       def array_element_type(type)
         type.arguments.first
       end
+
+      def common_numeric_type(left_type, right_type)
+        left_type = left_type.backing_type if left_type.is_a?(Types::EnumBase)
+        right_type = right_type.backing_type if right_type.is_a?(Types::EnumBase)
+        return unless left_type.is_a?(Types::Primitive) && right_type.is_a?(Types::Primitive)
+        return unless left_type.numeric? && right_type.numeric?
+        return left_type if left_type == right_type
+
+        return common_integer_type(left_type, right_type) if left_type.integer? && right_type.integer?
+        return wider_float_type(left_type, right_type) if left_type.float? && right_type.float?
+
+        float_type, integer_type = left_type.float? ? [left_type, right_type] : [right_type, left_type]
+        return unless integer_type.integer? && integer_type.fixed_width_integer?
+
+        float_type
+      end
+
+      def common_integer_type(left_type, right_type)
+        left_type = left_type.backing_type if left_type.is_a?(Types::EnumBase)
+        right_type = right_type.backing_type if right_type.is_a?(Types::EnumBase)
+        return unless left_type.is_a?(Types::Primitive) && right_type.is_a?(Types::Primitive)
+        return unless left_type.integer? && right_type.integer?
+        return left_type if left_type == right_type
+        return unless left_type.fixed_width_integer? && right_type.fixed_width_integer?
+
+        # Same signedness: the wider type wins. Mixed signed/unsigned: promote to
+        # the narrowest signed type that holds both operands' full ranges. A
+        # strictly-wider signed type covers an unsigned operand; equal-width or
+        # wider unsigned operands widen to the next signed width. Mixing with a
+        # 64-bit unsigned type has no safe signed common type, so callers fall
+        # back to requiring an explicit cast.
+        if left_type.signed_integer? == right_type.signed_integer?
+          return left_type.integer_width >= right_type.integer_width ? left_type : right_type
+        end
+
+        signed_type, unsigned_type = if left_type.signed_integer?
+          [left_type, right_type]
+        else
+          [right_type, left_type]
+        end
+
+        return signed_type if signed_type.integer_width > unsigned_type.integer_width
+
+        signed_type_above_width(unsigned_type.integer_width)
+      end
+
+      def signed_type_above_width(width)
+        case width
+        when 8 then Types::Registry.primitive("short")
+        when 16 then Types::Registry.primitive("int")
+        when 32 then Types::Registry.primitive("long")
+        end
+      end
+
+      def wider_float_type(left_type, right_type)
+        left_type.float_width >= right_type.float_width ? left_type : right_type
+      end
     end
   end
 end

data/lib/milk_tea/core/types.rb

@@ -1712,10 +1712,6 @@ module MilkTea
       GenericInstance.new("ptr", [type])
     end
 
-    def self.integer_type?(type)
-      type.is_a?(Primitive) && %w[int ptr_uint i8 i16 i32 i64 u8 u16 u32 u64].include?(type.name)
-    end
-
     def self.array_type?(type)
       type.is_a?(GenericInstance) && type.name == "array" && type.arguments.length == 2
     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

@@ -443,10 +443,6 @@ module MilkTea
           { items: [] }
         end
 
-        def refresh_workspace_diagnostics
-          @protocol.write_notification('workspace/diagnostic/refresh', nil)
-        end
-
         def find_match_end_line(lines, match_start_idx)
           return nil if match_start_idx >= lines.length
 

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

@@ -37,11 +37,15 @@ module MilkTea
           result.empty? ? nil : result
         end
 
+        TRIGGER_KIND_INCOMPLETE = 2
+        MAX_COMPLETION_SESSION_ENTRIES = 64
+
         def handle_completion(params)
           stages = new_perf_stages
           total_start = stages ? monotonic_time : nil
           uri      = params['textDocument']['uri']
           @current_completion_uri = uri
+          @current_completion_trigger_kind = params.dig('context', 'triggerKind') || 1
           lsp_line = params['position']['line']
           lsp_char = params['position']['character']
           branch = 'none'
@@ -49,50 +53,61 @@ module MilkTea
 
           prefix = measure_perf_stage(stages, 'prefix') { current_word_prefix(uri, lsp_line, lsp_char) }
 
+          # Completion session re-filtering: when the editor keeps requesting
+          # while the prefix grows (triggerFromIncompleteCompletions), re-filter
+          # the previously computed candidate pool instead of rebuilding it.
+          response = measure_perf_stage(stages, 'session') { completion_session_response(uri, lsp_line, lsp_char, prefix) }
+          if response
+            branch = 'session'
+            item_count = response[:items].length
+            return response
+          end
+
+          branch, item_count, response = measure_perf_stage(stages, 'compute') { compute_completion_items(uri, lsp_line, lsp_char, prefix, stages) }
+          store_completion_session(uri, lsp_line, lsp_char, prefix, response)
+          response
+        rescue StandardError => e
+          branch = 'error'
+          warn "Error in completion handler: #{e.message}"
+          { isIncomplete: false, items: [] }
+        ensure
+          log_request_stage_breakdown('textDocument/completion', total_start, uri: uri, stages: stages, summary: "branch=#{branch} items=#{item_count}")
+        end
+
+        def compute_completion_items(uri, lsp_line, lsp_char, prefix, stages)
           import_items = measure_perf_stage(stages, 'import_context') { import_completions(uri, lsp_line, lsp_char) }
           if import_items
-            branch = 'import'
-            item_count = import_items.length
-            return { isIncomplete: false, items: import_items }
+            return ['import', import_items.length, { isIncomplete: false, items: import_items }]
           end
 
           facts = measure_perf_stage(stages, 'facts') { @workspace.get_facts(uri) }
 
           unless facts
-            branch = 'no-facts'
-            return { isIncomplete: false, items: [] }
+            return ['no-facts', 0, { isIncomplete: false, items: [] }]
           end
 
           # Attribute context: complete inside @[...]
           attr_items = attribute_completions(facts, uri, lsp_line, lsp_char)
           if attr_items
-            branch = 'attribute'
-            item_count = attr_items.length
-            return { isIncomplete: false, items: attr_items }
+            return ['attribute', attr_items.length, { isIncomplete: false, items: attr_items }]
           end
 
           # Format string interpolation: complete inside f"... #{ }
           fmt_items = format_string_completions(facts, uri, lsp_line, lsp_char)
           if fmt_items
-            branch = 'format-string'
-            item_count = fmt_items.length
-            return { isIncomplete: false, items: fmt_items }
+            return ['format-string', fmt_items.length, { isIncomplete: false, items: fmt_items }]
           end
 
           # Named argument completions: inside function/struct call e.g. Point(x: 1, |)
           named_items = named_argument_completions(facts, uri, lsp_line, lsp_char)
           if named_items
-            branch = 'named-arg'
-            item_count = named_items.length
-            return { isIncomplete: false, items: named_items }
+            return ['named-arg', named_items.length, { isIncomplete: false, items: named_items }]
           end
 
           # Specialization context: inside name[...]
           spec_items = specialization_completions(facts, uri, lsp_line, lsp_char)
           if spec_items
-            branch = 'specialization'
-            item_count = spec_items.length
-            return { isIncomplete: false, items: spec_items }
+            return ['specialization', spec_items.length, { isIncomplete: false, items: spec_items }]
           end
 
           # When user is typing after '.', return module members or method completions.
@@ -105,7 +120,6 @@ module MilkTea
           if dot_recv
             # Module member access: rl.init_window, rl.RAYWHITE, etc.
             if (module_binding = facts.imports[dot_recv])
-              branch = 'module'
               items = measure_perf_stage(stages, 'build') do
                 result = []
                 module_binding.functions.each do |fname, binding|
@@ -152,8 +166,7 @@ module MilkTea
                 end
                 result
               end
-              item_count = items.length
-              return { isIncomplete: false, items: items }
+              return ['module', items.length, { isIncomplete: false, items: items }]
             end
             if (type_receiver = measure_perf_stage(stages, 'type_receiver') { resolve_type_receiver_info(facts, dot_recv, dot_recv_path) })
               receiver_label = type_receiver[:label]
@@ -162,7 +175,6 @@ module MilkTea
 
               # Enum/Flags member access: Color.RED, KeyboardKey.A, etc.
               if type.is_a?(Types::EnumBase)
-                branch = 'enum-members'
                 items = measure_perf_stage(stages, 'build') do
                   type.members.filter_map do |mname|
                     next if !prefix.empty? && !mname.start_with?(prefix)
@@ -176,13 +188,11 @@ module MilkTea
                     }
                   end
                 end
-                item_count = items.length
-                return { isIncomplete: false, items: items }
+                return ['enum-members', items.length, { isIncomplete: false, items: items }]
               end
 
               # Variant arm access: Option.none, Result.success, etc.
               if type.is_a?(Types::Variant)
-                branch = 'variant-arms'
                 items = measure_perf_stage(stages, 'build') do
                   type.arm_names.filter_map do |aname|
                     next if !prefix.empty? && !aname.start_with?(prefix)
@@ -196,13 +206,11 @@ module MilkTea
                     }
                   end
                 end
-                item_count = items.length
-                return { isIncomplete: false, items: items }
+                return ['variant-arms', items.length, { isIncomplete: false, items: items }]
               end
 
               # Nested struct type members: ShapeGroup.CircleData, etc.
               if type.is_a?(Types::Struct) && type.respond_to?(:nested_types) && type.nested_types.any?
-                branch = 'nested-types'
                 items = measure_perf_stage(stages, 'build') do
                   type.nested_types.filter_map do |nt_name, _nt_type|
                     next if !prefix.empty? && !nt_name.start_with?(prefix)
@@ -216,15 +224,12 @@ module MilkTea
                     }
                   end
                 end
-                item_count = items.length
-                return { isIncomplete: false, items: items } unless items.empty?
+                return ['nested-types', items.length, { isIncomplete: false, items: items }] unless items.empty?
               end
 
               items = measure_perf_stage(stages, 'build') { completion_items_for_type_receiver(facts, type, prefix) }
               unless items.empty?
-                branch = 'type-receiver'
-                item_count = items.length
-                return { isIncomplete: false, items: items }
+                return ['type-receiver', items.length, { isIncomplete: false, items: items }]
               end
             end
 
@@ -237,17 +242,13 @@ module MilkTea
                   receiver_type = measure_perf_stage(stages, 'imported_value_receiver') { val_binding.type }
                   items = measure_perf_stage(stages, 'build') { completion_items_for_value_receiver(facts, receiver_type, prefix) }
                   unless items.empty?
-                    branch = 'imported-value-receiver'
-                    item_count = items.length
-                    return { isIncomplete: false, items: items }
+                    return ['imported-value-receiver', items.length, { isIncomplete: false, items: items }]
                   end
                 end
               else
                 chain_items = measure_perf_stage(stages, 'value_chain') { value_chain_completions(facts, dot_recv_path, lsp_line, lsp_char, prefix) }
                 if chain_items
-                  branch = 'value-chain'
-                  item_count = chain_items.length
-                  return { isIncomplete: false, items: chain_items }
+                  return ['value-chain', chain_items.length, { isIncomplete: false, items: chain_items }]
                 end
               end
             end
@@ -255,14 +256,11 @@ module MilkTea
             if (receiver_type = measure_perf_stage(stages, 'value_receiver') { resolve_dot_receiver_value_type(facts, dot_recv, lsp_line + 1, lsp_char + 1) })
               items = measure_perf_stage(stages, 'build') { completion_items_for_value_receiver(facts, receiver_type, prefix) }
               unless items.empty?
-                branch = 'value-receiver'
-                item_count = items.length
-                return { isIncomplete: false, items: items }
+                return ['value-receiver', items.length, { isIncomplete: false, items: items }]
               end
             end
 
             # Method completions on a non-module receiver.
-            branch = 'method-fallback'
             method_items = measure_perf_stage(stages, 'build') do
               result = []
               facts.methods.each do |_recv_type, methods|
@@ -296,10 +294,9 @@ module MilkTea
               method_items = method_items.first(MAX_COMPLETION_ITEMS)
               item_count = MAX_COMPLETION_ITEMS
             end
-            return { isIncomplete: truncated, items: method_items }
+            return ['method-fallback', item_count, { isIncomplete: truncated, items: method_items }]
           end
 
-          branch = 'global'
           items = measure_perf_stage(stages, 'build') do
             result = []
             function_docs_cache = {}
@@ -450,13 +447,51 @@ module MilkTea
             items = items.first(MAX_COMPLETION_ITEMS)
             item_count = MAX_COMPLETION_ITEMS
           end
-          { isIncomplete: truncated, items: items }
-        rescue StandardError => e
-          branch = 'error'
-          warn "Error in completion handler: #{e.message}"
-          { isIncomplete: false, items: [] }
-        ensure
-          log_request_stage_breakdown('textDocument/completion', total_start, uri: uri, stages: stages, summary: "branch=#{branch} items=#{item_count}")
+          ['global', item_count, { isIncomplete: truncated, items: items }]
+        end
+
+        # Serve a previously computed candidate pool when the editor is
+        # re-triggering with a longer prefix (triggerFromIncompleteCompletions)
+        # on the same line. Safe only when the text before the cursor is a strict
+        # extension of the cached context and the word prefix has grown; re-filter
+        # the (already prefix-filtered) pool with the longer prefix.
+        def completion_session_response(uri, lsp_line, lsp_char, prefix)
+          return nil if prefix.empty?
+          return nil unless @current_completion_trigger_kind == TRIGGER_KIND_INCOMPLETE
+
+          content = @workspace.get_content(uri)
+          line_prefix = (content.split("\n", -1)[lsp_line] || '')[0...lsp_char]
+          cached = @completion_session_cache[[uri, lsp_line]]
+          return nil unless cached
+          return nil unless line_prefix.start_with?(cached[:line_prefix])
+          return nil unless prefix.start_with?(cached[:prefix])
+
+          items = cached[:items].select { |item| item[:label].to_s.start_with?(prefix) }
+          { isIncomplete: cached[:isIncomplete], items: items }
+        end
+
+        def store_completion_session(uri, lsp_line, lsp_char, prefix, response)
+          return if prefix.empty?
+
+          content = @workspace.get_content(uri)
+          line_prefix = (content.split("\n", -1)[lsp_line] || '')[0...lsp_char]
+          key = [uri, lsp_line]
+          @completion_session_cache[key] = {
+            line_prefix: line_prefix,
+            prefix: prefix,
+            isIncomplete: response[:isIncomplete],
+            items: response[:items],
+          }
+          if @completion_session_order_set.add?(key)
+            @completion_session_order << key
+            evict_completion_sessions while @completion_session_order.length > MAX_COMPLETION_SESSION_ENTRIES
+          end
+        end
+
+        def evict_completion_sessions
+          key = @completion_session_order.shift
+          @completion_session_cache.delete(key)
+          @completion_session_order_set.delete(key)
         end
 
         def value_chain_completions(facts, dot_recv_path, lsp_line, lsp_char, prefix)
@@ -821,6 +856,11 @@ module MilkTea
           return params if name.to_s.empty?
 
           uri = data['uri'] || ''
+          key = [uri, name]
+          if @completion_resolve_cache.key?(key)
+            return @completion_resolve_cache[key]
+          end
+
           definition_entry = @workspace.find_definition_token_global(name, preferred_uri: uri)
           return params unless definition_entry
 
@@ -828,7 +868,7 @@ module MilkTea
           docs = signature_help_markdown_for_doc_comment(doc_comment)
           return params if docs.empty?
 
-          params.merge('documentation' => { 'kind' => 'markdown', 'value' => docs })
+          @completion_resolve_cache[key] = params.merge('documentation' => { 'kind' => 'markdown', 'value' => docs })
         rescue StandardError => e
           warn "Error in completion resolve handler: #{e.message}"
           params
@@ -862,6 +902,7 @@ module MilkTea
 
           current_path = uri_to_path(uri)
           return nil unless current_path
+          current_path = File.expand_path(current_path)
 
           roots = MilkTea::ModuleRoots.roots_for_path(current_path)
           fs_dir = dir_segments.join(File::SEPARATOR)
@@ -870,23 +911,13 @@ module MilkTea
           filter_lower = filter.downcase
 
           roots.each do |root|
-            search_dir = fs_dir.empty? ? root : File.join(root, fs_dir)
-            next unless File.directory?(search_dir)
-
-            Dir.children(search_dir).sort.each do |name|
-              next if name.start_with?('.')
-              full_path = File.join(search_dir, name)
-
-              if name.end_with?('.mt')
-                mod_name = name.delete_suffix('.mt')
-                next if mod_name.start_with?('.')
-                next if full_path == current_path
-                next unless filter.empty? || mod_name.downcase.start_with?(filter_lower)
-                modules[mod_name] = mod_name
-              elsif File.directory?(full_path) && module_dir_contains_mt?(full_path)
-                next unless filter.empty? || name.downcase.start_with?(filter_lower)
-                modules[name] = name
-              end
+            names = @workspace.module_importable_names(root, fs_dir, current_path: current_path)
+            next unless names
+
+            names.each_key do |mod_name|
+              next unless filter.empty? || mod_name.downcase.start_with?(filter_lower)
+
+              modules[mod_name] = mod_name
             end
           end
 
@@ -904,14 +935,6 @@ module MilkTea
           end
         end
 
-        def module_dir_contains_mt?(dir)
-          Dir.children(dir).any? do |name|
-            next false if name.start_with?('.')
-            full = File.join(dir, name)
-            name.end_with?('.mt') || (File.directory?(full) && module_dir_contains_mt?(full))
-          end
-        end
-
         def attribute_completions(facts, uri, line, char)
           content = @workspace.get_content(uri)
           return nil unless content

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

@@ -142,6 +142,10 @@ module MilkTea
                   end
                 end
               end
+              # Fresh facts just landed for this document; let the editor
+              # re-fetch semantic tokens so analyzed highlighting replaces the
+              # lexical fallback that was served while facts were unavailable.
+              refresh_client_semantic_tokens
             elsif perf_logging?
               @diagnostics_perf[:dropped_stale] += 1
             end
@@ -223,12 +227,6 @@ module MilkTea
           dependency_export_surface_fingerprint(previous_content) != dependency_export_surface_fingerprint(current_content)
         end
 
-        def semantic_tokens_allow_last_good_fallback?(uri)
-          @diagnostics_mutex.synchronize do
-            @diagnostics_pending.key?(uri) || @diagnostics_enqueued.include?(uri)
-          end
-        end
-
         def notify_diagnostic_errors(uri, diagnostics)
           errors = diagnostics.select { |d| d.is_a?(Hash) && (d["severity"] || d[:severity]) == 1 }
           return if errors.empty?

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

@@ -10,19 +10,29 @@ module MilkTea
           stages = new_perf_stages
           total_start = stages ? monotonic_time : nil
           uri = params['textDocument']['uri']
+
+          content_hash = @workspace.get_content(uri).hash
+          facts = @workspace.get_facts(uri)
+          facts_id = facts&.object_id
+          cached = @document_symbol_cache[uri]
+          if cached && cached[:content_hash] == content_hash && cached[:facts_id] == facts_id
+            return cached[:result]
+          end
+
           symbols = measure_perf_stage(stages, 'symbols') { @workspace.get_symbols(uri) }
           result = measure_perf_stage(stages, 'format') { symbols.map { |sym| format_document_symbol(sym) } }
 
-          # Enrich with hierarchical children from AST
-          ast = @workspace.get_ast(uri)
+          # Enrich with hierarchical children from AST. Use the facts' own AST so
+          # binding_resolution node object_ids line up with the outline locals.
+          ast = facts&.ast || @workspace.get_ast(uri)
           if ast && result
-            facts = @workspace.get_facts(uri)
             enrich_with_children(result, ast, facts)
           end
 
           module_name = resolve_outline_module_name(uri)
           result = wrap_in_module_hierarchy(result, module_name, uri) if module_name && result&.any?
 
+          @document_symbol_cache[uri] = { content_hash: content_hash, facts_id: facts_id, result: result }
           result
         rescue StandardError => e
           warn "Error in documentSymbol handler: #{e.message}"