mt-lang 0.4.1 → 0.4.21

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

@@ -190,7 +190,8 @@ module MilkTea
               "return type mismatch: expected #{return_type}, got #{value_type}",
               expression: statement.value,
               contextual_int_to_float: contextual_int_to_float_target?(return_type),
-              line: statement.line,
+              line: (statement.line unless statement.value),
+              column: (statement.column unless statement.value),
             )
           when AST::DeferStmt
             with_loop_barrier do

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

@@ -459,8 +459,8 @@ module MilkTea
           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]
+          lines = @workspace.document_lines(uri)
+          line_prefix = (lines[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])
@@ -473,8 +473,8 @@ module MilkTea
         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]
+          lines = @workspace.document_lines(uri)
+          line_prefix = (lines[lsp_line] || '')[0...lsp_char]
           key = [uri, lsp_line]
           @completion_session_cache[key] = {
             line_prefix: line_prefix,
@@ -875,8 +875,7 @@ module MilkTea
         end
 
         def import_completions(uri, lsp_line, lsp_char)
-          content = @workspace.get_content(uri)
-          lines = content.split("\n", -1)
+          lines = @workspace.document_lines(uri)
           line = lines[lsp_line] || ''
           stripped = line.lstrip
           return nil unless stripped.start_with?('import ')
@@ -936,9 +935,7 @@ module MilkTea
         end
 
         def attribute_completions(facts, uri, line, char)
-          content = @workspace.get_content(uri)
-          return nil unless content
-          lines = content.split("\n", -1)
+          lines = @workspace.document_lines(uri)
           line_text = lines[line] || ''
           return nil if line_text.empty?
 
@@ -980,9 +977,7 @@ module MilkTea
         def format_string_completions(facts, uri, line, char)
           return nil unless facts
 
-          content = @workspace.get_content(uri)
-          return nil unless content
-          lines = content.split("\n", -1)
+          lines = @workspace.document_lines(uri)
           line_text = lines[line] || ''
           return nil if line_text.empty?
 
@@ -1045,9 +1040,7 @@ module MilkTea
         def named_argument_completions(facts, uri, line, char)
           return nil unless facts
 
-          content = @workspace.get_content(uri)
-          return nil unless content
-          lines = content.split("\n", -1)
+          lines = @workspace.document_lines(uri)
           line_text = lines[line] || ''
           return nil if line_text.empty?
 
@@ -1109,9 +1102,7 @@ module MilkTea
         def specialization_completions(facts, _uri, line, char)
           return nil unless facts
 
-          content = @workspace.get_content(_uri)
-          return nil unless content
-          lines = content.split("\n", -1)
+          lines = @workspace.document_lines(_uri)
           line_text = lines[line] || ''
           return nil if line_text.empty?
 

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

@@ -295,9 +295,8 @@ module MilkTea
         end
 
         def current_word_prefix(uri, lsp_line, lsp_char)
-          content = @workspace.get_content(uri)
-          lines   = content.split("\n", -1)
-          line    = lines[lsp_line] || ''
+          lines = @workspace.document_lines(uri)
+          line  = lines[lsp_line] || ''
           # Walk backwards from cursor to find start of current word
           char_idx = [lsp_char - 1, line.length - 1].min
           return '' if char_idx < 0

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

@@ -284,6 +284,8 @@ module MilkTea
         def invalidate_cache(uri, clear_last_good: false)
           @tokens_cache.delete(uri)
           @ast_cache.delete(uri)
+          @definition_token_index.delete(uri)
+          @line_cache.delete(uri)
           @symbols_cache.delete(uri)
           @doc_comments_cache.delete(uri)
           @facts_cache_mutex.synchronize do

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

@@ -48,7 +48,6 @@ module MilkTea
         private
 
         def candidate_definition_uris(name, exclude_uri: nil)
-          matcher = definition_line_matcher(name)
           open_uris, indexed_uris = @document_state_mutex.synchronize do
             [@open_documents.keys, @indexed_documents.keys]
           end
@@ -57,33 +56,33 @@ module MilkTea
           warmed_candidates = nil
           warmed_uris = nil
           @definition_cache_mutex.synchronize do
-            warmed_candidates = @definition_candidate_uris[name].dup
+            warmed_candidates = @definition_candidate_uris[name].to_a
             warmed_uris = @definition_names_by_uri.keys.to_set
           end
 
-          matches = warmed_candidates.to_a.filter_map do |doc_uri|
-            next if doc_uri == exclude_uri
-
-            doc_uri
-          end
+          matches = warmed_candidates.reject { |doc_uri| doc_uri == exclude_uri }
 
+          # One-time lazy index: extract each document's definition names and
+          # cache them so repeat lookups are Set-membership checks instead of
+          # re-scanning every indexed document's full content with a regex on
+          # each lookup (which scaled with total workspace bytes).
           ordered_uris.each do |doc_uri|
             next if doc_uri == exclude_uri
             next if warmed_uris.include?(doc_uri)
 
             content = get_content(doc_uri)
             next if content.empty?
-            next unless content.match?(matcher)
 
             warm_definition_candidates_for_uri(doc_uri, content)
-            matches << doc_uri
           end
 
-          matches.uniq
-        end
+          @definition_cache_mutex.synchronize do
+            @definition_candidate_uris[name].each do |doc_uri|
+              matches << doc_uri unless doc_uri == exclude_uri
+            end
+          end
 
-        def definition_line_matcher(name)
-          /#{DEFINITION_LINE_PREFIX}#{Regexp.escape(name)}\b/
+          matches.uniq
         end
 
         def cache_definition_entry(name, entry)

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

@@ -126,13 +126,18 @@ module MilkTea
           total = paths.length
           paths.each_with_index do |path, idx|
             file_uri = path_to_uri(path)
+            content = nil
             @document_state_mutex.synchronize do
-              @indexed_documents[file_uri] ||= begin
+              content = @indexed_documents[file_uri] ||= begin
                 File.read(path)
               rescue StandardError
                 nil
               end
             end
+            # Warm the definition-name index for this file so later global
+            # definition lookups hit Set-membership checks instead of scanning
+            # every indexed document's content.
+            warm_definition_candidates_for_uri(file_uri, content) if content
             if progress && total > 0
               pct = ((idx + 1) * 100 / total).clamp(0, 100)
               progress.call(pct, "#{idx + 1}/#{total} files")

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

@@ -79,10 +79,9 @@ module MilkTea
         # Scan text up to the cursor to find the innermost open function call context.
         # Returns { name:, active_parameter: } or nil if not inside a call.
         def find_call_context(uri, lsp_line, lsp_char)
-          content = get_content(uri)
-          return nil if content.empty?
+          lines = document_lines(uri)
+          return nil if lines.empty?
 
-          lines = content.split("\n", -1)
           cursor_line = lines[lsp_line] || ''
           prefix = lsp_line.positive? ? lines[0...lsp_line].join("\n") + "\n" : ''
           text = prefix + cursor_line[0...lsp_char]
@@ -150,14 +149,19 @@ module MilkTea
         end
 
         def token_contains_position?(token, target_line, target_char)
-          segments = token.lexeme.split("\n", -1)
-          end_line = token.line + segments.length - 1
-          return false if target_line < token.line || target_line > end_line
+          return false if target_line < token.line
+
+          lexeme = token.lexeme
+          unless lexeme.include?("\n")
+            return false if target_line > token.line
 
-          if segments.length == 1
-            return token.column <= target_char && target_char < (token.column + segments.first.length)
+            return token.column <= target_char && target_char < (token.column + lexeme.length)
           end
 
+          segments = lexeme.split("\n", -1)
+          end_line = token.line + segments.length - 1
+          return false if target_line > end_line
+
           if target_line == token.line
             return token.column <= target_char && target_char <= (token.column + segments.first.length - 1)
           end
@@ -178,8 +182,7 @@ module MilkTea
         end
 
         def find_dot_receiver_path(uri, lsp_line, lsp_char)
-          content = get_content(uri)
-          lines = content.split("\n", -1)
+          lines = document_lines(uri)
           line_str = lines[lsp_line] || ''
 
           idx = [lsp_char - 1, line_str.length - 1].min
@@ -222,39 +225,56 @@ module MilkTea
         # (def, struct, union, enum, flags, variant, type, const, var) for the given name.
         # Returns the identifier Token, or nil if not found.
         def find_definition_token(uri, name, before_line: nil, before_char: nil)
-          tokens = get_tokens(uri)
-          return nil if tokens.nil?
-
-          nearest = nil
-          tokens.each_cons(2) do |kw_tok, id_tok|
-            next unless DEFINITION_KEYWORDS.include?(kw_tok.type)
-            next unless id_tok.type == :identifier && id_tok.lexeme == name
+          candidates = definition_token_index(uri)[name]
+          return nil if candidates.nil? || candidates.empty?
 
-            if before_line
-              next if id_tok.line > before_line
-              next if id_tok.line == before_line && before_char && id_tok.column >= before_char
-            end
-
-            if nearest.nil? || id_tok.line > nearest.line || (id_tok.line == nearest.line && id_tok.column > nearest.column)
-              nearest = id_tok
+          if before_line
+            matches = candidates.select do |tok|
+              tok.line < before_line || (tok.line == before_line && (!before_char || tok.column < before_char))
             end
+            return matches.max_by { |tok| [tok.line, tok.column] } unless matches.empty?
           end
 
-          return nearest if nearest
+          candidates.first
+        end
 
-          tokens.each_cons(2) do |kw_tok, id_tok|
-            next unless DEFINITION_KEYWORDS.include?(kw_tok.type)
-            next unless id_tok.type == :identifier && id_tok.lexeme == name
+        # Return the cached line array for +uri+, so hot request paths (e.g.
+        # completion) do not re-split the whole document once per helper.
+        def document_lines(uri)
+          @document_state_mutex.synchronize do
+            return @line_cache[uri] if @line_cache.key?(uri)
+          end
 
-            return id_tok
+          lines = get_content(uri).split("\n", -1)
+          @document_state_mutex.synchronize do
+            @line_cache[uri] = lines
           end
-          nil
+          lines
         end
 
         private
 
         # ── Symbol extraction (token-based, no AST position requirement) ────────
 
+        # Lazily build a per-uri map of definition identifier tokens keyed by
+        # name, so repeated definition lookups are O(definitions-with-name)
+        # instead of re-scanning the document's full token stream each time.
+        def definition_token_index(uri)
+          @definition_token_index[uri] ||= begin
+            tokens = get_tokens(uri)
+            index = Hash.new { |hash, key| hash[key] = [] }
+            if tokens
+              tokens.each_cons(2) do |kw_tok, id_tok|
+                next unless DEFINITION_KEYWORDS.include?(kw_tok.type)
+                next unless id_tok.type == :identifier
+
+                index[id_tok.lexeme] << id_tok
+              end
+            end
+            index
+          end
+        end
+
         def extract_symbols_from_tokens(uri)
           tokens = get_tokens(uri)
           return [] if tokens.nil?

data/lib/milk_tea/lsp/workspace.rb

@@ -37,7 +37,7 @@ module MilkTea
       # adjacent tokens, and the inner keyword (e.g. :function) is always followed
       # by the identifier. If the lexer ever merges a compound keyword into a
       # single token type (e.g. :const_function), it must be added here.
-      DEFINITION_KEYWORDS = %i[function struct union enum flags variant type const var let extending opaque interface event].freeze
+      DEFINITION_KEYWORDS = %i[function struct union enum flags variant type const var let extending opaque interface event].to_set.freeze
       DOC_COMMENT_PREFIX = '##'
       DOC_TAG_PATTERN = /\A\s*@([A-Za-z_][A-Za-z0-9_-]*)(?:\s+(.*))?\z/
       DEFINITION_LINE_PREFIX = /^(?:\s)*(?:(?:public|foreign|external)\s+)*(?:function|struct|union|enum|flags|variant|type|const|var|let|extending|opaque|interface|event)\s+/m
@@ -55,6 +55,8 @@ module MilkTea
         @tokens_cache = {}   # uri -> [Token]
         @last_good_tokens_cache = {} # uri -> last known-good [Token]
         @ast_cache = {}      # uri -> AST::SourceFile (nil on parse failure)
+        @definition_token_index = {} # uri -> { name => [Token] } definition tokens by name
+        @line_cache = {} # uri -> [String] split lines, refreshed on invalidation
         @facts_cache = {} # uri -> SemanticAnalyzer::Facts (projection of cached tooling snapshot facts)
         @tooling_snapshot_cache = {} # uri -> SemanticAnalyzer::ToolingSnapshot (facts may be nil on structural failure)
         @symbols_cache = {}  # uri -> [{name, kind, line, column}]
@@ -103,6 +105,8 @@ module MilkTea
         @tokens_cache.clear
         @last_good_tokens_cache.clear
         @ast_cache.clear
+        @definition_token_index.clear
+        @line_cache.clear
         @facts_cache.clear
         @tooling_snapshot_cache.clear
         @symbols_cache.clear

data/lib/milk_tea/tooling/cli/commands/run.rb

@@ -72,11 +72,12 @@ module MilkTea
           argv: @argv.dup,
           **options.except(:timings)
         )
-        unless @out.equal?($stdout) || preview_notice_emitted
+        live = $stdout.tty?
+        unless (@out.equal?($stdout) && live) || preview_notice_emitted
           @out.write(result.stdout)
         end
         @out.flush if @out.respond_to?(:flush)
-        @err.write(result.stderr) unless @err.equal?($stderr)
+        @err.write(result.stderr) unless @err.equal?($stderr) && live
         info("[cached]") if result.cached
         result.exit_status
       end

data/lib/milk_tea/tooling/cli/commands/test.rb

@@ -399,21 +399,14 @@ module MilkTea
           return 1
         end
 
-        testing_import = ast.imports.find { |import| import.path.parts == %w[std testing] }
-        unless testing_import
-          @err.puts("a test file must import std.testing: #{path}")
-          return 1
-        end
-        testing_alias = testing_import.alias_name || testing_import.path.parts.last
-
         death_tests, normal_tests = tests.partition { |test| expect_fatal_attribute?(test) }
 
         exit_code = 0
 
         unless normal_tests.empty?
           runner_source = source.dup
-          runner_source << "\n\n" << test_runner_main(testing_alias, normal_tests.map(&:name))
-          exit_code = run_synthesized_tests(path, runner_source, options:, locked:)
+          runner_source << "\n\n" << test_runner_main(normal_tests.map(&:name))
+          exit_code = run_normal_tests(path, runner_source, normal_tests.map(&:name), options:, locked:)
         end
 
         death_tests.each do |death_test|
@@ -459,30 +452,53 @@ module MilkTea
       def death_test_runner_main(test_name)
         [
           "function main() -> int:",
-          "    match #{test_name}():",
-          "        Result.success:",
-          "            return 0",
-          "        Result.failure:",
-          "            return 0",
+          "    #{test_name}()",
+          "    return 0",
         ].join("\n") + "\n"
       end
 
-      def test_runner_main(testing_alias, test_names)
-        lines = ["function main() -> int:"]
-        lines << "    var __mt_test_stats = #{testing_alias}.Stats.create()"
+      # The runner binary runs exactly one test per invocation, selected by
+      # `argv[1]`. This gives per-test isolation: an aborting assertion in one
+      # test cannot suppress the results of its siblings.
+      def test_runner_main(test_names)
+        lines = ["function main(args: span[str]) -> int:"]
+        lines << "    let which = if args.len > 1: args[1] else: \"\""
+        lines << "    match which:"
         test_names.each do |name|
-          lines << "    __mt_test_stats = #{testing_alias}.record(__mt_test_stats, #{name.inspect}, #{name}())"
+          lines << "        \"#{name}\":"
+          lines << "            #{name}()"
         end
-        lines << "    return #{testing_alias}.summarize(__mt_test_stats)"
+        lines << "        _:"
+        lines << "            return 2"
+        lines << "    return 0"
         lines.join("\n") + "\n"
       end
 
-      def run_synthesized_tests(source_path, runner_source, options:, locked:)
+      def run_normal_tests(source_path, runner_source, test_names, options:, locked:)
         with_synthesized_binary(source_path, runner_source, options:, locked:) do |binary_path|
-          run_test_binary(binary_path)
+          exit_code = 0
+          test_names.each do |name|
+            output, status, timed_out = spawn_sandboxed(binary_path, [name])
+            if timed_out
+              @out.puts("FAIL - #{name}: timed out")
+              exit_code = 1
+            elsif status&.exitstatus == 0
+              @out.puts("ok   - #{name}")
+            else
+              @out.puts("FAIL - #{name}: #{first_fail_message(output)}")
+              exit_code = 1
+            end
+            @out.flush if @out.respond_to?(:flush)
+          end
+          exit_code
         end
       end
 
+      def first_fail_message(output)
+        line = output.to_s.lines.map(&:chomp).find { |entry| !entry.strip.empty? }
+        line.nil? || line.strip.empty? ? "test aborted" : line.strip
+      end
+
       def with_synthesized_binary(source_path, runner_source, options:, locked:)
         directory = File.dirname(File.expand_path(source_path))
         runner_path = File.join(directory, "__mt_test_runner_#{Process.pid}.mt")
@@ -508,30 +524,13 @@ module MilkTea
         end
       end
 
-      def run_test_binary(binary_path)
-        output, status, timed_out = spawn_sandboxed(binary_path)
-        @out.write(output)
-        @out.flush if @out.respond_to?(:flush)
-
-        if timed_out
-          @err.puts("test run timed out after #{@test_timeout_seconds || TEST_RUN_TIMEOUT_SECONDS}s")
-          return 1
-        end
-        if status&.signaled?
-          @err.puts("test run crashed (signal #{status.termsig})")
-          return 1
-        end
-
-        status&.exitstatus || 1
-      end
-
-      def spawn_sandboxed(binary_path)
+      def spawn_sandboxed(binary_path, args = [])
         timeout_seconds = @test_timeout_seconds || TEST_RUN_TIMEOUT_SECONDS
         memory_bytes = @test_memory_bytes || TEST_RUN_MEMORY_LIMIT_BYTES
         reader, writer = IO.pipe
         spawn_options = { out: writer, err: writer, pgroup: true }
         spawn_options[:rlimit_as] = memory_bytes unless @test_sanitize
-        pid = Process.spawn(binary_path, **spawn_options)
+        pid = Process.spawn(binary_path, *args, **spawn_options)
         writer.close
 
         status = nil

data/lib/milk_tea/tooling/cli.rb

@@ -597,10 +597,11 @@ module MilkTea
           root), recursively discovers every .mt file that contains @[test] functions,
           runs each as its own test binary, and prints an aggregate summary.
 
-          Functions annotated with @[test] must take no parameters and return
-          std.testing.Check. `mtc test` synthesizes a runner that invokes each
-          test through std.testing and reports the results; a test file must import
-          std.testing and must not define `main`.
+          Functions annotated with @[test] must take no parameters and return void;
+          a failing test aborts via the `assert`/`expect`/`expect_eq`/`expect_ne`
+          intrinsics. `mtc test` synthesizes a runner that invokes each test in its
+          own process (for isolation) and reports the results. A test file must not
+          define `main`.
 
           Each test binary runs under a wall-clock timeout and an address-space
           memory cap so a hanging or runaway test cannot stall or exhaust the host.

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

@@ -105,14 +105,25 @@ module MilkTea
       def terminating_expression?(expression)
         case expression
         when AST::Call
-          terminating_callee?(expression.callee) || static_assert_false?(expression)
+          terminating_callee?(expression.callee) || static_assert_false?(expression) || assertion_false?(expression)
         when AST::Specialization
-          terminating_callee?(expression.callee) || static_assert_false?(expression)
+          terminating_callee?(expression.callee) || static_assert_false?(expression) || assertion_false?(expression)
         else
           false
         end
       end
 
+      def assertion_false?(expression)
+        return false unless expression.is_a?(AST::Call)
+
+        callee = expression.callee
+        return false unless callee.is_a?(AST::Identifier)
+        return false unless %w[assert expect].include?(callee.name)
+
+        first_arg = expression.arguments.first
+        first_arg.is_a?(AST::BooleanLiteral) && first_arg.value == false
+      end
+
       def static_assert_false?(expression)
         return false unless expression.callee.is_a?(AST::Identifier)
         return false unless expression.callee.name == "static_assert"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.21
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -150,6 +150,7 @@ files:
 - docs/language-design.md
 - docs/language-manual.md
 - docs/lsp-performance.md
+- docs/testing.md
 - lib/milk_tea.rb
 - lib/milk_tea/base.rb
 - lib/milk_tea/bindings.rb
@@ -233,6 +234,7 @@ files:
 - lib/milk_tea/core/lexer/trivia.rb
 - lib/milk_tea/core/lowering.rb
 - lib/milk_tea/core/lowering/artifacts.rb
+- lib/milk_tea/core/lowering/assertions.rb
 - lib/milk_tea/core/lowering/async/analysis.rb
 - lib/milk_tea/core/lowering/async/async_lowering.rb
 - lib/milk_tea/core/lowering/async/frame_builder.rb
@@ -609,7 +611,6 @@ files:
 - std/sync.mt
 - std/tar.mt
 - std/terminal.mt
-- std/testing.mt
 - std/thread.mt
 - std/time.mt
 - std/timer.mt
@@ -629,7 +630,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.4.1 installed!
+  Milk Tea 0.4.21 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH