mt-lang 0.3.40 → 0.3.41

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a57605301758f1ff1307cfb5aa7300bb73876be082b9736f853bf14dce18352
-  data.tar.gz: 8d540b3326a74c0a8370d5799b19eadb78f8d579899ffdfed263847bbfa0c367
+  metadata.gz: 91b5015b218da9925b56895b551063fca825ca776fc336fe898ef17e332aae4e
+  data.tar.gz: 46e4a2da80edfb7c64fc847ee10844c9f5d36572df35105ab6ed51e2455d347a
 SHA512:
-  metadata.gz: c7ff36f0b7a609a7c4dbd69264c70ee7dca22201d520753e254609a3009844c23572c578cbdb5802afdd04897559b578f1e539b5c9c6c2a97c64f16f5e286062
-  data.tar.gz: 1987f20a6c919b3c8341a339c6473292bf31866a07ffe1805707153b077a282284686366dd299eeb02e91de23a83eec1b8aaa837fc901eadefe58acf54df07a9
+  metadata.gz: 0c1dcedaf98ef374c9dd21cded75f8512c755a63e4a3a155e494d9edf098b2d53da3b258edab5d63066a2a9eaa3c2a3883aa69241608509085caf398c1edecc1
+  data.tar.gz: a427c7ad0f2475b7dc5cccadcb6cc143ab195f906b7b9b13407a7e754043fd8550495c7dc750f5f27c92e2eca13477d9f6697650bddd515403526812b1dac06b

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/core/module_loader.rb

@@ -158,7 +158,30 @@ module MilkTea
 
     def load_file(path)
       resolved_path = self.class.resolve_source_path(path, platform: @platform, error_class: ModuleLoadError)
-      @ast_cache[resolved_path] ||= parse_file(resolved_path)
+      @ast_cache[resolved_path] ||= cached_or_parse_file(resolved_path)
+    end
+
+    # Parse +resolved_path+, reusing the shared-cache parsed AST when the source
+    # is disk-backed and unchanged. ASTs are immutable Data, so sharing them
+    # across loaders (and worker threads) is safe; node_ids are assigned at
+    # parse time and analyses keep their own per-node result hashes. Source
+    # files covered by source_overrides are always re-parsed so live editor
+    # buffers win.
+    def cached_or_parse_file(resolved_path)
+      if use_shared_cache_for?(resolved_path)
+        mtime = source_mtime(resolved_path)
+        if mtime
+          entry = @shared_cache[[:ast, resolved_path]]
+          return entry[:ast] if entry && entry[:mtime] == mtime
+        end
+      end
+
+      ast = parse_file(resolved_path)
+      if use_shared_cache_for?(resolved_path)
+        mtime = source_mtime(resolved_path)
+        @shared_cache[[:ast, resolved_path]] = { mtime:, ast: } if mtime
+      end
+      ast
     end
 
     def check_file(path)
@@ -166,7 +189,14 @@ module MilkTea
     end
 
     def with_check_context(path, &block)
-      Types::Registry.reset!
+      # NOTE: Types::Registry.reset! is intentionally NOT called here. The LSP
+      # runs check_program_collecting concurrently on diagnostics workers and
+      # the request thread; a reset would clear the global intern pool while
+      # another thread is mid-analysis, causing threads to intern duplicate type
+      # instances. Interning is idempotent and the pool stays small (bounded by
+      # the type universe), so it is safe to let it grow for the process
+      # lifetime. Single-threaded entry points that want a clean slate (Build#build,
+      # server re-initialize) reset explicitly.
       requested_path = File.expand_path(path)
       previous_platform = @platform
       @platform ||= self.class.platform_suffix_for_path(requested_path)
@@ -541,7 +571,7 @@ module MilkTea
       return [resolved_path, nil, @analysis_cache[resolved_path]] if @analysis_cache.key?(resolved_path)
       return [resolved_path, nil, extra_cache[resolved_path]] if extra_cache&.key?(resolved_path)
 
-      if use_shared_cache?
+      if use_shared_cache_for?(resolved_path)
         entry = @shared_cache[resolved_path]
         if entry
           mtime = source_mtime(resolved_path)
@@ -566,7 +596,7 @@ module MilkTea
     end
 
     def update_shared_cache(resolved_path, analysis)
-      return unless use_shared_cache?
+      return unless use_shared_cache_for?(resolved_path)
 
       mtime = source_mtime(resolved_path)
       @shared_cache[resolved_path] = { mtime:, analysis: } if mtime
@@ -730,8 +760,13 @@ module MilkTea
       )
     end
 
-    def use_shared_cache?
-      @shared_cache && @source_overrides.empty?
+    # The shared cache stores per-module analyses keyed by resolved path. It is
+    # consulted only for paths NOT covered by source_overrides: source-overridden
+    # files reflect live editor buffers (or in-memory sources) that never match
+    # disk, so their entries would be stale by construction. This lets a single
+    # open document invalidate only itself while imported modules stay cached.
+    def use_shared_cache_for?(resolved_path)
+      @shared_cache && !@source_overrides.key?(resolved_path)
     end
   end
 end

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

@@ -41,16 +41,28 @@ module MilkTea
         _intern([:string_view]) { StringView.new }
       end
 
+      # Param signature for intern keys. Parameter#eql? is name-insensitive
+      # (assignability must not depend on parameter names), so arrays of
+      # Parameter objects would conflate fn(value: int) with fn(arg0: int) in
+      # the intern pool. Embedding names here keeps distinct signatures
+      # distinct across independent programs sharing a long-lived pool (the LSP
+      # never resets the registry between checks).
+      def self.param_signature(params)
+        params.map { |p| [p.name, p.type, p.mutable, p.passing_mode, p.boundary_type] }
+      end
+
       def self.function(name, params:, return_type:, receiver_type: nil, receiver_editable: false, variadic: false, external: false)
         params_frozen = params.freeze
-        _intern([:function, name, params_frozen, return_type, receiver_type, receiver_editable, variadic, external]) {
+        param_key = param_signature(params_frozen)
+        _intern([:function, name, param_key, return_type, receiver_type, receiver_editable, variadic, external]) {
           Function.new(name, params: params_frozen, return_type: return_type, receiver_type: receiver_type, receiver_editable: receiver_editable, variadic: variadic, external: external)
         }
       end
 
       def self.proc(params:, return_type:)
         params_frozen = params.freeze
-        _intern([:proc, params_frozen, return_type]) { Proc.new(params: params_frozen, return_type: return_type) }
+        param_key = param_signature(params_frozen)
+        _intern([:proc, param_key, return_type]) { Proc.new(params: params_frozen, return_type: return_type) }
       end
 
       def self.parameter(name, type, mutable: false, passing_mode: :plain, boundary_type: nil)

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

@@ -360,6 +360,8 @@ module MilkTea
         end
 
         def handle_document_diagnostic(params)
+          return { kind: 'full', items: [] } if request_cancelled?(@current_request_id)
+
           uri = params.dig('textDocument', 'uri')
           return { kind: 'full', items: [] } unless uri
 
@@ -404,6 +406,8 @@ module MilkTea
         end
 
         def handle_workspace_diagnostic(params)
+          return { items: [] } if request_cancelled?(@current_request_id)
+
           progress = nil
           if (work_done_token = params['workDoneToken'])
             progress = create_progress_handle(@protocol, work_done_token)
@@ -416,7 +420,13 @@ module MilkTea
           end
 
           all_uris = @workspace.open_document_uris
-          items = all_uris.filter_map do |uri|
+          items = []
+          all_uris.each do |uri|
+            # Coarse cancellation: workspace/diagnostic can iterate many cold
+            # documents (~1s each); bail early when the client cancels so we do
+            # not sink CPU into results that will be discarded.
+            break if request_cancelled?(@current_request_id)
+
             content = @workspace.get_content(uri)
             next if content.empty?
 
@@ -426,10 +436,10 @@ 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: [], version: nil }
+              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, version: nil }
+              items << { uri: uri, kind: 'full', resultId: result_id, items: diagnostics, version: nil }
             end
           end
 

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

@@ -202,28 +202,72 @@ module MilkTea
           end.join("\n")
         end
 
+        # Declaration-prefix regex. Unlike the old form, it also covers the
+        # `const function` compound, async/foreign/external/editable/static
+        # modifiers, and `attribute` declarations. `static_assert` is not
+        # matched: `static` requires whitespace before the keyword, and a bare
+        # module-level statement cannot be a declaration.
+        SURFACE_DECL_LINE = %r{\A(?:(?:public|foreign|external|async|editable|static|const)\s+)*(?:function|struct|union|enum|flags|variant|interface|event|type|const|var|extending|opaque|attribute)\b}
+
+        # A bare `name: Type` line. Only struct/union fields (and continuation
+        # parameter lines) take this shape; local declarations use `let`/`var`,
+        # named arguments use `=`, and match-arm labels start with a keyword or
+        # pattern. Requires a type-like token after the colon so `_:` arm labels
+        # are not treated as surface.
+        SURFACE_FIELD_LINE = /\A[A-Za-z_][A-Za-z0-9_]*\s*:\s*[A-Za-z_\[\]]/
+
+        # Over-approximation of the module's externally-observable surface. It
+        # must never MISS a surface change (a miss leaves shared-cache analyses
+        # of dependents stale); false positives only trigger a harmless
+        # re-analysis. In addition to declaration lines it captures:
+        #   - `@[...]` attributes (packed/align/deprecated change layout/docs)
+        #   - multi-line declaration headers, so parameter/signature edits on
+        #     continuation lines are detected
+        #   - struct/union field lines (`name: Type`)
         def dependency_export_surface_fingerprint(content)
-          content.to_s.each_line.filter_map do |line|
-            stripped = line.strip
-            next if stripped.empty? || stripped.start_with?('#')
+          lines = content.to_s.lines.map(&:strip)
+          surface = []
+          i = 0
+          while i < lines.length
+            line = lines[i]
+            if line.empty? || line.start_with?('#')
+              i += 1
+              next
+            end
 
-            if stripped.match?(/\A(?:public\s+)?(?:type|struct|union|enum|flags|variant|interface|event|function|const|var)\b/)
-              stripped
-            elsif stripped.match?(/\Aextending\b/)
-              stripped
-            elsif stripped.match?(/\Apublic\s+(?:function|const|var|type)\b/)
-              stripped
+            if line.start_with?('@[') || line.match?(SURFACE_DECL_LINE) || line.match?(SURFACE_FIELD_LINE)
+              surface << line
+              # Multi-line header: absorb continuation lines until the
+              # terminating ':' so edits inside the header are surfaced too.
+              unless line.end_with?(':')
+                i += 1
+                while i < lines.length
+                  cont = lines[i]
+                  break if cont.empty?
+                  surface << cont
+                  i += 1
+                  break if cont.end_with?(':')
+                end
+                next
+              end
             end
-          end.join("\n")
+            i += 1
+          end
+          surface.join("\n")
         end
 
         def dependency_refresh_required_for_edit?(changed_uri, previous_content, current_content)
           return false if previous_content == current_content
           return true if dependency_import_fingerprint(previous_content) != dependency_import_fingerprint(current_content)
 
-          related_uris = @workspace.related_open_document_uris(changed_uri)
-          return false unless related_uris.length > 1
+          # Keep the open-document dependency index fresh (related_open_document_uris
+          # updates it as a side effect) so dependent tracking stays accurate.
+          @workspace.related_open_document_uris(changed_uri)
 
+          # A surface edit can invalidate shared-cache analyses of NON-open
+          # dependents (their cached entries are recomputed against this module
+          # on their next pull), so clearing must not be gated on there being
+          # open dependents to refresh.
           dependency_export_surface_fingerprint(previous_content) != dependency_export_surface_fingerprint(current_content)
         end
 

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

@@ -43,7 +43,12 @@ module MilkTea
           invalidate_document_caches(uri)
           current_content = @workspace.get_content(uri)
           refresh_open_document_dependency_state(uri, previous_content: previous_content, current_content: current_content)
-          schedule_diagnostics(uri, lint_tier: :fast) unless @workspace.background_document?(uri)
+          # This server is always pull-based (diagnosticProvider), so the
+          # client's textDocument/diagnostic request asks for the full tier.
+          # Scheduling a lighter tier here computes in the worker and then
+          # duplicates the full lint on the request thread; keep the tiers
+          # aligned so the pull can serve the worker's result.
+          schedule_diagnostics(uri, lint_tier: :full) unless @workspace.background_document?(uri)
           nil
         end
 
@@ -65,12 +70,23 @@ module MilkTea
 
         def handle_did_close(params)
           uri = params['textDocument']['uri']
+          previous_content = @workspace.get_content(uri)
           cancel_diagnostics(uri)
           @workspace.close_document(uri)
           invalidate_document_caches(uri)
           @diagnostic_report_cache.delete(uri)
           @workspace_diagnostic_cache.delete(uri)
-          refresh_open_document_dependency_state(uri)
+          # Once closed, the buffer is no longer authoritative. If it differed
+          # from disk, module analyses computed against it (for dependents and
+          # the file itself) are stale; drop the whole shared cache. Closing is
+          # a rare per-file event, so an unconditional clear is cheap and safe.
+          disk_content = begin
+            path = uri_to_path(uri)
+            path && File.file?(path) ? File.read(path) : nil
+          rescue StandardError
+            nil
+          end
+          clear_shared_module_cache if previous_content != disk_content
           unless defined?(@pull_diagnostics_active) && @pull_diagnostics_active
             @protocol.write_notification('textDocument/publishDiagnostics', {
               uri: uri,

data/lib/milk_tea/lsp/workspace/caches.rb

@@ -99,14 +99,41 @@ module MilkTea
 
           lock_wait_start = total_start ? monotonic_time : nil
           if @facts_state_mutex.try_lock
+            # No analysis is in flight; computing here is fine (cold paths,
+            # tests). It does not block on other work.
             begin
               compute_snapshot.call
             ensure
               @facts_state_mutex.unlock
             end
           elsif allow_last_good_fallback && last_good_snapshot
-            cache_state = 'last_good'
+            # Facts exist from a prior pass; never block on the in-flight one.
             snapshot = last_good_snapshot
+            cache_state = 'last_good'
+          elsif allow_last_good_fallback
+            # No facts yet and a background analysis is computing this document.
+            # Wait briefly (bounded) for it so the request usually returns fresh
+            # facts instead of a lexical fallback — without duplicating the work
+            # (we never run analysis here) or blocking indefinitely. Beyond the
+            # budget, serve nil and let the handler fall back.
+            deadline = monotonic_time + (IN_FLIGHT_FACTS_WAIT_MS / 1000.0)
+            acquired = false
+            while monotonic_time < deadline
+              if @facts_state_mutex.try_lock
+                acquired = true
+                break
+              end
+              sleep 0.02
+            end
+            if acquired
+              begin
+                compute_snapshot.call
+              ensure
+                @facts_state_mutex.unlock
+              end
+            else
+              cache_state = 'nil'
+            end
           else
             @facts_state_mutex.synchronize do
               lock_wait_ms = elapsed_ms(lock_wait_start) if lock_wait_start

data/lib/milk_tea/lsp/workspace/dependency_graph.rb

@@ -107,6 +107,37 @@ module MilkTea
           @full_reverse_index_built = false
         end
 
+        # Drop all cached module analyses (and the per-uri snapshots derived from
+        # them) when an analysis input that was captured in those analyses is no
+        # longer authoritative — e.g. a closed document whose buffer differed from
+        # disk. Kept rare: closing a file is infrequent, so a wholesale clear is
+        # safer than reasoning about which dependents could have observed the
+        # closed buffer. Open documents keep their last-known-good snapshots so
+        # they keep serving rich features while re-analysis lands.
+        def clear_shared_module_cache
+          @facts_state_mutex.synchronize do
+            @facts_cache_mutex.synchronize do
+              all_open = @document_state_mutex.synchronize { @open_documents.keys }
+              preserved_facts = all_open.each_with_object({}) do |open_uri, preserved|
+                facts = @last_good_facts_cache[open_uri]
+                preserved[open_uri] = facts if facts
+              end
+              preserved_snapshots = all_open.each_with_object({}) do |open_uri, preserved|
+                snapshot = @last_good_tooling_snapshot_cache[open_uri]
+                preserved[open_uri] = snapshot if snapshot
+              end
+              @shared_module_cache.clear
+              @facts_cache.clear
+              @tooling_snapshot_cache.clear
+              @diagnostics_cache.clear
+              @last_good_facts_cache.clear
+              @last_good_tooling_snapshot_cache.clear
+              preserved_snapshots.each { |open_uri, snapshot| @last_good_tooling_snapshot_cache[open_uri] = snapshot }
+              preserved_facts.each { |open_uri, facts| @last_good_facts_cache[open_uri] = facts }
+            end
+          end
+        end
+
         def update_dependency_index(uri, facts)
           imported_module_names = if facts
             facts.imports.each_value.filter_map(&:name).to_set

data/lib/milk_tea/lsp/workspace/store.rb

@@ -72,7 +72,13 @@ module MilkTea
           invalidate_cache(uri)
           enqueue_definition_warmup(uri) unless background_document?(uri)
 
-          @shared_module_cache.clear
+          # The shared module cache is intentionally NOT cleared here. Imported
+          # module analyses only become stale when this file's dependency surface
+          # (imports or exported declarations) changes; a body-only edit leaves
+          # them valid. handle_did_change detects surface changes via
+          # dependency_refresh_required_for_edit? and clears the cache through
+          # refresh_import_dependent_caches. Clearing it on every keystroke forced
+          # a full re-analysis of every transitive module per edit.
           dependent_uris = @facts_cache_mutex.synchronize do
             all_open = @document_state_mutex.synchronize { @open_documents.keys }
             dependent_open_document_uris_for(uri, all_open)

data/lib/milk_tea/lsp/workspace.rb

@@ -22,6 +22,12 @@ module MilkTea
       DOCUMENT_SOURCES = %w[active-editor visible-editor background-document].freeze
       PERF_LOG_THRESHOLD_MS = 1000
 
+      # How long a request thread waits (when no facts are available yet) for an
+      # in-flight background analysis to finish before falling back to lexical/
+      # nil results. Bounds the main-loop stall while usually returning fresh
+      # facts; request threads never run the analysis themselves in this window.
+      IN_FLIGHT_FACTS_WAIT_MS = Integer(ENV.fetch('MILK_TEA_LSP_FACTS_WAIT_MS', '500'))
+
       # Token types that introduce a named definition, in order of precedence.
       #
       # NOTE: this list is intentionally minimal. Multi-keyword prefixes such as

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.3.40
+  version: 0.3.41
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -625,7 +625,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.40 installed!
+  Milk Tea 0.3.41 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH