mt-lang 0.3.39 → 0.3.41

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "../core"
-require_relative "cst_formatter"
 
 module MilkTea
   class FormatterError < StandardError; end
@@ -49,12 +48,12 @@ module MilkTea
 
     def self.preserve_format(source, path:, profile: nil)
       cst = profile_phase(profile, "format.cst") { build_cst(source, path:) }
-      profile_phase(profile, "format.cst_fmt") { CSTFormatter.format(cst) }
+      profile_phase(profile, "format.cst_fmt") { cst.reconstruct }
     end
 
     def self.tidy_format(source, path:, max_line_length: DEFAULT_MAX_LINE_LENGTH, profile: nil)
       cst = profile_phase(profile, "format.cst") { build_cst(source, path:) }
-      normalized = profile_phase(profile, "format.normalize") { CSTFormatter.format_normalized(cst) }
+      normalized = profile_phase(profile, "format.normalize") { cst.reconstruct_normalized }
       wrapped = profile_phase(profile, "format.wrap") { wrap_long_argument_lists(normalized, max_line_length:, path:) }
       profile_phase(profile, "format.blank_lines") { normalize_blank_lines(wrapped, path:) }
     end

data/lib/milk_tea/tooling/linter/fix_engine.rb

@@ -17,6 +17,7 @@ module MilkTea
         when "redundant-else"         then redundant_else_edits(lines, warning)
         when "redundant-return"       then redundant_return_edits(lines, warning)
         when "redundant-type-annotation" then redundant_type_annotation_edits(lines, warning)
+        when "prefer-inline-methods"  then prefer_inline_methods_edits(lines, warning)
         when "unused-import"          then unused_import_edits(lines, warning)
         when "trailing-list-comma"    then trailing_list_comma_edits(lines, warning)
         else []
@@ -152,6 +153,51 @@ module MilkTea
         [FixEdit.new(start_line: line_idx, start_char: 0, end_line: line_idx + 1, end_char: 0, new_text: "")]
       end
 
+      # Moves the methods of an `extending X:` block inline into the matching
+      # `struct X:` declaration. Only rewrites when the struct immediately
+      # precedes the extending block (blank lines allowed between them); other
+      # layouts are left alone since the move would be non-local.
+      def self.prefer_inline_methods_edits(lines, warning)
+        name = warning.symbol_name
+        return [] unless name && warning.line
+
+        struct_idx = lines.index { |l| l.match?(/\A\s*struct\s+#{Regexp.escape(name)}\b/) }
+        return [] unless struct_idx
+
+        last_member_idx = nil
+        ((struct_idx + 1)...lines.length).each do |i|
+          l = lines[i]
+          break if !l.chomp.empty? && !l.start_with?(" ", "\t")
+
+          last_member_idx = i unless l.chomp.empty?
+        end
+        return [] unless last_member_idx
+
+        ext_start_idx = warning.line - 1
+        return [] unless last_member_idx < ext_start_idx
+
+        ext_end_idx = ext_start_idx
+        ((ext_start_idx + 1)...lines.length).each do |i|
+          l = lines[i]
+          break if !l.chomp.empty? && !l.start_with?(" ", "\t")
+
+          ext_end_idx = i unless l.chomp.empty?
+        end
+
+        method_lines = lines[(ext_start_idx + 1)..ext_end_idx].to_a
+        method_lines.shift while method_lines.first && method_lines.first.chomp.empty?
+        method_lines.pop while method_lines.last && method_lines.last.chomp.empty?
+        return [] if method_lines.empty?
+
+        between = lines[(last_member_idx + 1)...ext_start_idx]
+        return [] unless between.all? { |l| l.chomp.empty? }
+
+        method_text = method_lines.join
+        new_text = "#{lines[last_member_idx].chomp}\n\n#{method_text}"
+
+        [FixEdit.new(start_line: last_member_idx, start_char: 0, end_line: ext_end_idx + 1, end_char: 0, new_text: new_text)]
+      end
+
       def self.unused_import_edits(lines, warning)
         return [] unless warning.line
 

data/lib/milk_tea/tooling/linter/rules.rb

@@ -586,6 +586,38 @@ module MilkTea
       def lvalue_expression?(expression)
         expression.is_a?(AST::Identifier) || expression.is_a?(AST::MemberAccess) || expression.is_a?(AST::IndexAccess)
       end
+      # ── prefer-inline-methods ──────────────────────────────────────────────
+      # Flag `extending X:` blocks whose receiver struct is declared in the same
+      # file, suggesting the methods be written inline inside the struct body
+      # (which desugars to the identical `extending` block).
+
+      def emit_prefer_inline_methods_warnings(source_file)
+        struct_names = source_file.declarations.filter_map { |decl| decl.name if decl.is_a?(AST::StructDecl) }.to_set
+        return if struct_names.empty?
+
+        source_file.declarations.each do |declaration|
+          next unless declaration.is_a?(AST::ExtendingBlock)
+          next if declaration.inline
+
+          parts = declaration.type_name.name.parts
+          next unless parts.length == 1
+          next if declaration.type_name.arguments.any?
+
+          name = parts.first
+          next unless struct_names.include?(name)
+
+          @warnings << Warning.new(
+            path: @path,
+            line: declaration.line,
+            column: declaration.column,
+            length: name.length,
+            code: "prefer-inline-methods",
+            message: "methods on '#{name}' can be written inline inside the struct declaration",
+            severity: :hint,
+            symbol_name: name,
+          )
+        end
+      end
     end
   end
 end

data/lib/milk_tea/tooling/linter.rb

@@ -35,6 +35,7 @@ module MilkTea
       owning-release-double
       prefer-conditional-expression
       prefer-inline-if
+      prefer-inline-methods
       prefer-is-variant
       prefer-let
       prefer-let-else
@@ -69,6 +70,7 @@ module MilkTea
       redundant-ignored-match-binding
       prefer-let-else
       prefer-var-else
+      prefer-inline-methods
       redundant-bool-compare
       redundant-cast
       redundant-else
@@ -95,6 +97,7 @@ module MilkTea
       "redundant-type-annotation" => "Remove redundant type annotation",
       "prefer-let-else" => "Rewrite as let-else",
       "prefer-var-else" => "Rewrite as var-else",
+      "prefer-inline-methods" => "Inline methods into struct",
       "trailing-list-comma" => "Remove trailing list comma",
     }.freeze
     EVENT_STACK_SNAPSHOT_WARNING_THRESHOLD = 128
@@ -771,6 +774,7 @@ module MilkTea
       profile_phase("rule.doc_tag") { emit_doc_tag_warnings(ast) } if full_tier?
       profile_phase("rule.event_capacity") { emit_event_capacity_warnings(ast) }
       profile_phase("rule.trailing_list_comma") { emit_trailing_list_comma_warnings(ast) }
+      profile_phase("rule.prefer_inline_methods") { emit_prefer_inline_methods_warnings(ast) }
       profile_phase("rule.line_too_long") { emit_line_too_long_warnings }
       @warnings
     end

data/lib/milk_tea/tooling.rb

@@ -11,7 +11,6 @@ require_relative "tooling/sexpr_dumper"
 require_relative "tooling/sexpr_parser"
 require_relative "tooling/build"
 require_relative "tooling/run"
-require_relative "tooling/cst_formatter"
 require_relative "tooling/error_formatter"
 require_relative "tooling/formatter"
 require_relative "tooling/linter"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.3.39
+  version: 0.3.41
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -385,7 +385,6 @@ files:
 - lib/milk_tea/tooling/cli/commands/snapshot.rb
 - lib/milk_tea/tooling/cli/commands/test.rb
 - lib/milk_tea/tooling/cli/commands/toolchain.rb
-- lib/milk_tea/tooling/cst_formatter.rb
 - lib/milk_tea/tooling/debug_info_formatter.rb
 - lib/milk_tea/tooling/debug_map.rb
 - lib/milk_tea/tooling/docs_app.rb
@@ -626,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.39 installed!
+  Milk Tea 0.3.41 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH

data/lib/milk_tea/tooling/cst_formatter.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module MilkTea
-  class CSTFormatter
-    def self.format(cst)
-      cst.reconstruct
-    end
-
-    def self.format_normalized(cst)
-      cst.reconstruct_normalized
-    end
-  end
-end