mt-lang 0.3.40 → 0.3.42

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

@@ -248,7 +248,13 @@ module MilkTea
             raise_sema_error("unsupported expression #{expression.class.name}")
           end
 
-          @resolved_expr_types[@ctx.ast.node_ids[expression.object_id]] = type
+          # Specialized generic-instance bodies share the same AST nodes across
+          # substitutions, so a node-id keyed cache cannot be populated there:
+          # the last-checked instance would overwrite every other instance's
+          # types and leak wrong types to lowering, which reads this cache.
+          # Regular functions carry an empty (but non-nil) substitution hash, so
+          # only a non-empty hash identifies an instance body.
+          @resolved_expr_types[@ctx.ast.node_ids[expression.object_id]] = type unless @current_type_substitutions&.any?
           type
         end
       end
@@ -961,7 +967,7 @@ module MilkTea
         callable_kind = resolution.kind
         callable = resolution.value
         receiver = resolution.receiver
-        @resolved_call_kinds[@ctx.ast.node_ids[expression.callee.object_id]] = callable_kind
+        @resolved_call_kinds[@ctx.ast.node_ids[expression.callee.object_id]] = callable_kind unless @current_type_substitutions&.any?
 
         case callable_kind
         when :function

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

@@ -695,7 +695,9 @@ module MilkTea
         offset = CompileTime::Layout.offset_of(type, binding.const_value.field_name)
         return unless offset
 
-        @const_values[@ctx.ast.node_ids[expression.object_id]] = offset
+        # Same node-id key collision as resolved_expr_types: instance bodies
+        # share AST nodes across substitutions, so never cache their values.
+        @const_values[@ctx.ast.node_ids[expression.object_id]] = offset unless @current_type_substitutions&.any?
       end
 
       def infer_offsetof_type(type_ref, field_name, scopes: nil)

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

data/lib/milk_tea/tooling/docs_app.rb

@@ -18,7 +18,7 @@ module MilkTea
       "Files & I/O" => %w[fs path stdio],
       "System" => %w[ctype errno process time c],
       "Network & HTTP" => %w[net http uri cookie curl],
-      "Game & Graphics" => %w[raylib box2d flecs enet cgltf cjson],
+      "Game & Graphics" => %w[raylib box2d box3d flecs enet cgltf cjson],
       "Algorithms & AI" => %w[fsm behavior_tree goap],
       "Database & Matching" => %w[sqlite3 pcre2],
       "Utilities" => %w[cli terminal span spatial asset_pack],