mt-lang 0.4.2 → 0.4.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 726a973cae08da6d7927931a6fa51adc8106fd483709dede501b7e551e1d9103
-  data.tar.gz: 666501d1a75719851869d1467d7498e84c2b4fd18da6d52a41912343d2f52f43
+  metadata.gz: 60f503669467624ebec5461f2f5fb5c3dae9216718b4c445f182323b90e9f505
+  data.tar.gz: d5ace59e3fdadbe3a7ea75f740d0d1d2953088d1799b42e9e6899c900e50595a
 SHA512:
-  metadata.gz: 618b5705f9b727ce7d07b6ccf6576aa92d0380d7f4609393790fb8c64df1a3c7bd409151eabc800d95ca01d6636c8e26d43840758db90502ccf2757ad6800190
-  data.tar.gz: e9a6840730d61fee0b57c3339779169a31e91d84626230cc353c1e9b31a1e748b58a0b5c205d904bbb32ba0951bfd4874df3374c378a62c8a6e8277bc1fccffe
+  metadata.gz: e74f76c097577a41ccc21462f7ede0d2c2a77f84f883e0ca3026b6b3f966e4b87ba3cfc91eca5dc16165edbc50a6f2bcff6be7ef6be751a1ba95f86b472b6e00
+  data.tar.gz: 652e7de9f0afd01aeac1358af1c47a2a19bce244ec53838b5cfc65b103d44cafea61210d01ca766bf390d4b649268d50d6ac2c057ce40e09f64e25b24c4a3d76

data/README.md

@@ -20,7 +20,7 @@ It is the preferred first entry point for getting to know the language.
 If this file conflicts with `docs/language-manual.md`, the manual wins.
 `docs/language-design.md` is for design direction and rationale, not the authoritative implementation spec.
 
-Package manifests, build workflow, and run workflow are documented separately in `docs/build-guide.md`.
+Package manifests, build workflow, and run workflow are documented separately in `docs/build-guide.md`. The `@[test]` attribute, assertion intrinsics, and `mtc test` runner are documented in `docs/testing.md`.
 
 ## 1. File Kinds And Layout
 
@@ -860,6 +860,10 @@ Generics:
 Special recognized callables:
 
 - `fatal(message)`
+- `assert(condition, message?)` — runtime check; aborts when the `bool` condition is false
+- `expect(condition, message?)` — same as `assert`, always-on test assertion
+- `expect_eq(actual, expected, message?)` — compares with the language `==` operator (primitives, `str`, structs, variants, arrays) and aborts when the values differ
+- `expect_ne(actual, expected, message?)` — compares with `!=` and aborts when the values are equal
 - `ref_of(x)`
 - `const_ptr_of(x)`
 - `read(r)`
@@ -877,6 +881,8 @@ Special recognized callables:
 - `get(coll, index)` — recoverable array/span indexing returning `ptr[T]?`; null on out‑of‑bounds instead of aborting
 - `adapt[I](value)` — constructs a `dyn[I]` runtime interface value; verifies `value`'s type implements interface `I` at compile time
 
+`assert`, `expect`, `expect_eq`, and `expect_ne` are recognized in bare call position (not reserved words) and take an optional `str`/`cstr` message. When omitted, the compiler synthesizes a message carrying the source location; the message is only evaluated on the failing path. A literal-false `assert(false, ...)` / `expect(false, ...)` is treated as terminating control flow, so it satisfies the `else:` block of a `let ... else:` guard.
+
 Reference and pointer notes:
 
 - `read(ref_value)` explicitly projects the referent value. Use `read(handle) = value` to write through a bare `ref[T]` value.

data/docs/index.html

@@ -1879,6 +1879,10 @@ let sized = name[32]</code></pre>
     <table class="attr-table">
       <tr><th>Callable</th><th>Description</th></tr>
       <tr><td><code>fatal(message)</code></td><td>Terminate with message</td></tr>
+      <tr><td><code>assert(condition, message?)</code></td><td>Runtime check; aborts when the <code>bool</code> condition is false</td></tr>
+      <tr><td><code>expect(condition, message?)</code></td><td>Always-on test assertion (same as <code>assert</code>)</td></tr>
+      <tr><td><code>expect_eq(actual, expected, message?)</code></td><td>Compares with the language <code>==</code> (primitives, <code>str</code>, structs, variants, arrays); aborts when the values differ</td></tr>
+      <tr><td><code>expect_ne(actual, expected, message?)</code></td><td>Compares with <code>!=</code>; aborts when the values are equal</td></tr>
       <tr><td><code>ref_of(x)</code></td><td>Writable safe reference to an addressable lvalue</td></tr>
       <tr><td><code>const_ptr_of(x)</code></td><td>Read-only raw pointer to an addressable lvalue</td></tr>
       <tr><td><code>ptr_of(x)</code></td><td>Writable raw pointer from a mutable addressable lvalue</td></tr>
@@ -2660,6 +2664,7 @@ const ATOMS = new Set(['true','false','null'])
 const BUILTINS = new Set([
   'ref_of','ptr_of','const_ptr_of','read','reinterpret','zero','default',
   'hash','equal','order','size_of','align_of','offset_of','get','adapt','fatal',
+  'assert','expect','expect_eq','expect_ne',
   'field_of','callable_of','attribute_of','has_attribute','attribute_arg',
   'fields_of','members_of','attributes_of',
 ])

data/docs/language-manual.md

@@ -2,7 +2,7 @@
 
 This manual documents the Milk Tea language as implemented today in the lexer, parser, semantic checker, and compiler tests.
 
-Package manifests and build or run workflow are documented separately in `docs/build-guide.md`.
+Package manifests and build or run workflow are documented separately in `docs/build-guide.md`. The `@[test]` attribute, assertion intrinsics, and `mtc test` runner are documented in `docs/testing.md`.
 
 ## 1. Source Files And Modules
 
@@ -1225,6 +1225,10 @@ The call site specializes with a literal: `int_with_bits[64]`.
 Special recognized callables:
 
 - `fatal(message)`
+- `assert(condition, message?)` — runtime check; aborts with `message` when the `bool` condition is false
+- `expect(condition, message?)` — same as `assert`, always-on test assertion
+- `expect_eq(actual, expected, message?)` — compares with the language `==` operator (works for primitives, `str`, structs, variants, arrays) and aborts when the values differ
+- `expect_ne(actual, expected, message?)` — compares with `!=` and aborts when the values are equal
 - `ref_of(x)`
 - `const_ptr_of(x)`
 - `read(r)`
@@ -1242,6 +1246,8 @@ Special recognized callables:
 - `get(coll, index)` — recoverable array/span indexing returning `ptr[T]?`; null on out‑of‑bounds instead of aborting
 - `adapt[I](value)` — constructs a `dyn[I]` runtime interface value; verifies `value`'s type implements `I` at compile time
 
+`assert`, `expect`, `expect_eq`, and `expect_ne` are special recognized callables, not reserved words: they are recognized in bare call position and may be shadowed by user declarations like any ordinary name. Their message argument (when given) must be `str` or `cstr`; when omitted, the compiler synthesizes a message carrying the source location. The message is only evaluated on the failing path. A literal-false `assert(false, ...)` or `expect(false, ...)` is treated as terminating control flow (like `static_assert(false, ...)`), so it may be used where the checker requires guaranteed exit, such as the `else:` block of a `let ... else:` guard.
+
 `default[T]` requires an accessible zero-argument associated function `T.default()` that returns `T`.
 
 `hash[T](value)` lowers to `T.hash(value: const_ptr[T]) -> uint`, `equal[T](left, right)` lowers to `T.equal(left: const_ptr[T], right: const_ptr[T]) -> bool`, and `order[T](left, right)` lowers to `T.order(left: const_ptr[T], right: const_ptr[T]) -> int`. Each argument must already be a `ref[T]`, `ptr[T]`, or `const_ptr[T]`, or be a safe stored `T` lvalue that can be borrowed implicitly.
@@ -1547,6 +1553,7 @@ The auto-fix column corresponds to `mtc lint --fix`.
 | `shadow` | warning | — | Local binding shadows an outer binding with the same name |
 | `trailing-list-comma` | hint | yes | Trailing comma in call argument list is redundant |
 | `unreachable-code` | warning | — | Code after a guaranteed terminator cannot execute |
+| `redundant-unsafe` | hint | — | `unsafe` block contains no unsafe operations and can be removed |
 | `unused-import` | warning | yes | Import alias is never referenced |
 | `unused-local` | warning | — | Local binding is never referenced |
 | `unused-param` | warning | — | Parameter is never referenced |

data/docs/testing.md

@@ -0,0 +1,91 @@
+# Milk Tea Testing Guide
+
+This guide documents the in-language testing surface: the `assert`/`expect`/`expect_eq`/`expect_ne` intrinsics, the `@[test]` attribute, and the `mtc test` runner. The assertion intrinsics are part of the built-in callable surface (see `language-manual.md` §7); there is no standard-library testing module to import.
+
+## 1. Assertions
+
+Four abort-based assertion intrinsics are available in every module, in both tests and ordinary code:
+
+```mt
+assert(condition, message?)            # runtime check
+expect(condition, message?)            # always-on test assertion
+expect_eq(actual, expected, message?)  # compares with the language `==`
+expect_ne(actual, expected, message?)  # compares with `!=`
+```
+
+Rules:
+
+- `condition` must be `bool`. `expect_eq`/`expect_ne` compare with the language `==`/`!=` operators, so they work for primitives, `str`, structs, variants, and arrays.
+- `message` (when given) must be `str` or `cstr`; a `f"..."` format string flows straight in. When omitted, the compiler synthesizes a message carrying the source location.
+- On failure the program aborts through the same path as `fatal`. The message is only evaluated on the failing path, so a `f"..."` message costs nothing while the assertion holds.
+- `assert` defaults to always-on. `expect` is the test-flavored form and is always on.
+- A literal-false `assert(false, ...)` or `expect(false, ...)` is treated as terminating control flow (like `static_assert(false, ...)`), so it satisfies contexts that require guaranteed exit, such as the `else:` block of a `let ... else:` guard.
+
+## 2. Tests
+
+Tests are ordinary functions annotated with `@[test]`. They take no parameters and return `void`; a failing assertion aborts the test.
+
+```mt
+function square(x: int) -> int:
+    return x * x
+
+@[test]
+function test_square() -> void:
+    expect_eq(square(3), 9)
+    expect(square(4) > 0, "square must be positive")
+```
+
+Rules:
+
+- A test file must not define `main`; `mtc test` synthesizes the entry point.
+- A function annotated with `@[test] @[expect_fatal]` is a death test: it must abort (via `fatal`, a failed assertion, or a failed safety check) to pass.
+
+## 3. Running Tests
+
+```sh
+mtc test PATH            # run @[test] functions in one file
+mtc test DIR             # recursively run every test file under a directory
+```
+
+`mtc test` builds one runner binary per test file and runs each test in its own process, so an aborting assertion is isolated to its own test and cannot suppress the results of its siblings. Passing tests print `ok   - name`; failures print `FAIL - name: message`. The run is sandboxed with a wall-clock timeout (default 30s) and an address-space memory cap (default 1024 MB).
+
+Options:
+
+- `--timeout SECONDS` — per-test wall-clock timeout
+- `--mem MB` — per-test address-space memory cap
+- `--jobs N` — build and run N files in parallel (output stays in file order)
+- `-n SUBSTRING` — run only tests whose name contains SUBSTRING
+- `--format tap|junit` — machine-readable results for CI
+- `--sanitize` — build with AddressSanitizer/UBSan; any sanitizer error fails the run
+- `--profile debug|release`, `--platform linux|windows|wasm`, `--cc COMPILER` — build controls, same as `mtc build`
+
+A file containing `# expect-error: <text>` is a compile-fail fixture: `mtc test` requires the compiler to reject it with a diagnostic containing that text, instead of running it.
+
+## 4. Example
+
+```mt
+# tests/vec_test.mt
+import std.vec as vec
+
+@[test]
+function test_vec_push_and_len() -> void:
+    var values = vec.Vec[int].create()
+    defer: values.release()
+    values.push(1)
+    values.push(2)
+    expect_eq(values.len(), 2)
+
+@[test]
+@[expect_fatal]
+function test_vec_oob_aborts() -> void:
+    var values = vec.Vec[int].create()
+    defer: values.release()
+    values.push(1)
+    values.at(5)
+```
+
+```sh
+mtc test tests
+```
+
+See the `mtc test --help` text for the current full option list.

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/core/control_flow/builder.rb

@@ -254,7 +254,16 @@ module MilkTea
       end
 
       def fatal_expression?(expression)
-        expression.is_a?(AST::Call) && expression.callee.is_a?(AST::Identifier) && expression.callee.name == "fatal"
+        return true if expression.is_a?(AST::Call) && expression.callee.is_a?(AST::Identifier) && expression.callee.name == "fatal"
+
+        # A literal-false `assert`/`expect` always aborts, so it terminates the
+        # current control flow like a `fatal` call (matching static_assert(false)).
+        expression.is_a?(AST::Call) &&
+          expression.callee.is_a?(AST::Identifier) &&
+          %w[assert expect].include?(expression.callee.name) &&
+          (first_arg = expression.arguments.first) &&
+          first_arg.value.is_a?(AST::BooleanLiteral) &&
+          first_arg.value.value == false
       end
 
       def assignment_target_reads(target, operator)

data/lib/milk_tea/core/lowering/assertions.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module Lowering
+    module Assertions
+      ASSERT_CALL_NAMES = %w[assert expect expect_eq expect_ne].freeze
+
+      # Lowers an `assert`/`expect`/`expect_eq`/`expect_ne` expression statement
+      # into an `IR::IfStmt` whose then-branch aborts via `fatal`. The message is
+      # only evaluated on the failing path so unused messages cost nothing.
+      # Returns `nil` when the statement is not one of the assertion calls so the
+      # caller can fall through to ordinary expression-statement lowering.
+      def lower_assert_like_statement(statement, env:)
+        kind = assert_like_call_kind(statement.expression)
+        return nil unless kind
+
+        arguments = statement.expression.arguments
+        line = statement.expression.line
+        column = statement.expression.column
+        default_message = default_assert_message(kind, statement.line)
+
+        condition_ast = nil
+        message = nil
+        case kind
+        when "assert", "expect"
+          condition_ast = unary_expression("not", arguments.fetch(0).value, line:, column:)
+          message = arguments.length > 1 ? arguments.fetch(1).value : string_literal(default_message, line:, column:)
+        when "expect_eq"
+          condition_ast = binary_expression("!=", arguments.fetch(0).value, arguments.fetch(1).value, line:, column:)
+          message = arguments.length > 2 ? arguments.fetch(2).value : string_literal(default_message, line:, column:)
+        when "expect_ne"
+          condition_ast = binary_expression("==", arguments.fetch(0).value, arguments.fetch(1).value, line:, column:)
+          message = arguments.length > 2 ? arguments.fetch(2).value : string_literal(default_message, line:, column:)
+        end
+
+        # Hoist inline-proc/foreign-temporary setup out of the condition so the
+        # failure check itself stays a plain `if (!cond)` in C.
+        setup, prepared_condition, cleanups = prepare_expression_with_cleanups(
+          condition_ast,
+          env:,
+          expected_type: @ctx.types.fetch("bool"),
+        )
+
+        [
+          *setup,
+          IR::IfStmt.new(
+            condition: lower_expression(prepared_condition, env:, expected_type: @ctx.types.fetch("bool")),
+            then_body: [lower_fatal_expression_statement(message, line:, column:, env:)],
+            else_body: [],
+          ),
+          *cleanups.flat_map(&:itself),
+        ]
+      end
+
+      def assert_like_call_kind(expression)
+        return nil unless expression.is_a?(AST::Call)
+        return nil unless expression.callee.is_a?(AST::Identifier)
+        return nil unless ASSERT_CALL_NAMES.include?(expression.callee.name)
+
+        expression.callee.name
+      end
+
+      def default_assert_message(kind, line)
+        path = @ctx.current_analysis_path.to_s
+        case kind
+        when "assert" then "assertion failed at #{path}:#{line}"
+        when "expect" then "expectation failed at #{path}:#{line}"
+        when "expect_eq" then "expect_eq failed: values are not equal at #{path}:#{line}"
+        when "expect_ne" then "expect_ne failed: values are equal at #{path}:#{line}"
+        end
+      end
+
+      def lower_fatal_expression_statement(message, line:, column:, env:)
+        fatal_call = AST::Call.new(
+          callee: AST::Identifier.new(name: "fatal", line:, column:),
+          arguments: [AST::Argument.new(name: nil, value: message, line:, column:)],
+          line:,
+          column:,
+        )
+        IR::ExpressionStmt.new(
+          expression: lower_expression(fatal_call, env:, expected_type: @ctx.types.fetch("void")),
+          line:,
+          path: @ctx.current_analysis_path,
+        )
+      end
+
+      def unary_expression(operator, operand, line:, column:)
+        AST::UnaryOp.new(operator:, operand:, line:, column:)
+      end
+
+      def binary_expression(operator, left, right, line:, column:)
+        AST::BinaryOp.new(operator:, left:, right:, line:, column:)
+      end
+
+      def string_literal(value, line:, column:)
+        AST::StringLiteral.new(lexeme: value.inspect, value:, cstring: false, line:, column:)
+      end
+    end
+  end
+end

data/lib/milk_tea/core/lowering/block.rb

@@ -422,6 +422,11 @@ module MilkTea
       end
 
       def lower_expression_stmt(statement, lowered:, local_defers:, local_env:)
+        if (assert_statements = lower_assert_like_statement(statement, env: local_env))
+          lowered.concat(assert_statements)
+          return
+        end
+
         if (format_sink_statements = lower_explicit_format_sink_expression_statement(statement.expression, env: local_env, line: statement.line))
           lowered.concat(format_sink_statements)
           return

data/lib/milk_tea/core/lowering/calls.rb

@@ -271,6 +271,8 @@ module MilkTea
           )
         when :zero
           IR::ZeroInit.new(type:)
+        when :assert, :expect, :expect_eq, :expect_ne
+          raise LoweringError.new("#{kind} must be used as a statement", line: 0, column: 0, path: @ctx.current_analysis_path)
         when :fatal
           argument = expression.arguments.fetch(0)
           message_type = infer_expression_type(argument.value, env:)

data/lib/milk_tea/core/lowering/resolve.rb

@@ -6,6 +6,10 @@ module MilkTea
       include CompileTime::MethodFolding
       PASS_THROUGH_BUILTINS = {
         "fatal"         => :fatal,
+        "assert"        => :assert,
+        "expect"        => :expect,
+        "expect_eq"     => :expect_eq,
+        "expect_ne"     => :expect_ne,
         "ref_of"        => :ref_of,
         "const_ptr_of"   => :const_ptr_of,
         "read"          => :read,

data/lib/milk_tea/core/lowering.rb

@@ -26,6 +26,7 @@
 
 require_relative "lowering/scans"
 require_relative "lowering/declarations"
+require_relative "lowering/assertions"
 require_relative "lowering/events"
 require_relative "lowering/functions"
 require_relative "lowering/async/analysis"
@@ -107,6 +108,7 @@ module MilkTea
     include Lowering::Functions
     include Lowering::Async
     include Lowering::Block
+    include Lowering::Assertions
     include Lowering::Proc
     include Lowering::Loops
     include Lowering::Expressions

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

@@ -834,6 +834,37 @@ module MilkTea
 
         raise_sema_error("fatal expects str or cstr, got #{message_type}")
       end
+      def check_assert_call(kind, arguments, scopes:)
+        name = kind.to_s
+        raise_sema_error("#{name} does not support named arguments") if arguments.any?(&:name)
+        raise_sema_error("#{name} expects 1 or 2 arguments, got #{arguments.length}") unless arguments.length == 1 || arguments.length == 2
+
+        condition_type = infer_expression(arguments.fetch(0).value, scopes:, expected_type: @ctx.types.fetch("bool"))
+        ensure_assignable!(condition_type, @ctx.types.fetch("bool"), "#{name} condition must be bool, got #{condition_type}", expression: arguments.fetch(0).value)
+        check_assert_message(name, arguments[1]&.value, scopes:) if arguments.length == 2
+
+        @ctx.types.fetch("void")
+      end
+      def check_expect_eq_call(kind, arguments, scopes:)
+        name = kind.to_s
+        raise_sema_error("#{name} does not support named arguments") if arguments.any?(&:name)
+        raise_sema_error("#{name} expects 2 or 3 arguments, got #{arguments.length}") unless arguments.length == 2 || arguments.length == 3
+
+        left = arguments.fetch(0).value
+        right = arguments.fetch(1).value
+        operator = kind == :expect_ne ? "!=" : "=="
+        comparison = AST::BinaryOp.new(operator:, left:, right:, line: nil, column: nil)
+        infer_binary(comparison, scopes:, expected_type: @ctx.types.fetch("bool"))
+        check_assert_message(name, arguments[2]&.value, scopes:) if arguments.length == 3
+
+        @ctx.types.fetch("void")
+      end
+      def check_assert_message(name, message, scopes:)
+        return unless message
+
+        message_type = infer_expression(message, scopes:, expected_type: @ctx.types.fetch("str"))
+        raise_sema_error("#{name} message must be str or cstr, got #{message_type}") unless string_like_type?(message_type)
+      end
       def check_get_call(arguments, scopes:)
         raise_sema_error("get does not support named arguments") if arguments.any?(&:name)
         raise_sema_error("get expects 2 arguments, got #{arguments.length}") unless arguments.length == 2

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

@@ -1043,6 +1043,10 @@ module MilkTea
           check_order_call(callable, expression.arguments, scopes:)
         when :fatal
           check_fatal_call(expression.arguments, scopes:)
+        when :assert, :expect
+          check_assert_call(callable_kind, expression.arguments, scopes:)
+        when :expect_eq, :expect_ne
+          check_expect_eq_call(callable_kind, expression.arguments, scopes:)
         when :ref_of
           check_ref_of_call(expression.arguments, scopes:)
         when :const_ptr_of
@@ -1318,6 +1322,10 @@ module MilkTea
 
           return [:function, @ctx.top_level_functions.fetch(callee.name), nil] if @ctx.top_level_functions.key?(callee.name)
           return [:fatal, nil, nil] if callee.name == "fatal"
+          return [:assert, nil, nil] if callee.name == "assert"
+          return [:expect, nil, nil] if callee.name == "expect"
+          return [:expect_eq, nil, nil] if callee.name == "expect_eq"
+          return [:expect_ne, nil, nil] if callee.name == "expect_ne"
           return [:ref_of, nil, nil] if callee.name == "ref_of"
           return [:const_ptr_of, nil, nil] if callee.name == "const_ptr_of"
           return [:read, nil, nil] if callee.name == "read"

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"

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

@@ -209,6 +209,7 @@ module MilkTea
             check_prefer_try(statement.expression, statement.arms)
           end
         when AST::UnsafeStmt
+          check_redundant_unsafe(statement)
           @unsafe_depth += 1
           with_scope { visit_statement_list(statement.body) }
           @unsafe_depth -= 1
@@ -314,6 +315,7 @@ module MilkTea
             check_prefer_or_pattern(expression.arms, body_of: ->(arm) { arm.value })
           end
         when AST::UnsafeExpr
+          check_redundant_unsafe(expression)
           @unsafe_depth += 1
           visit_expression(expression.expression)
           @unsafe_depth -= 1
@@ -362,6 +364,21 @@ module MilkTea
           nil
         end
       end
+      def check_redundant_unsafe(node)
+        return unless @sema_facts
+        return if @sema_facts.required_unsafe_lines.include?(node.line)
+
+        @warnings << Warning.new(
+          path: @path,
+          line: node.line,
+          column: node.column,
+          length: "unsafe".length,
+          code: "redundant-unsafe",
+          message: "unsafe block contains no unsafe operations and can be removed",
+          severity: :hint,
+        )
+      end
+
       def visit_type_argument(argument)
         visit_expression(argument.value) if argument.respond_to?(:value)
       end

data/lib/milk_tea/tooling/linter.rb

@@ -22,17 +22,17 @@ module MilkTea
       borrow-and-mutate
       constant-condition
       dead-assignment
-      duplicate-if-condition
       directional-ffi-arg
       doc-tag
+      duplicate-if-condition
       event-capacity
       line-too-long
       loop-single-iteration
       missing-return
       noop-compound-assignment
-      platform-api-drift
-      owning-release-leak
       owning-release-double
+      owning-release-leak
+      platform-api-drift
       prefer-conditional-expression
       prefer-inline-if
       prefer-inline-methods
@@ -51,6 +51,7 @@ module MilkTea
       redundant-null-check
       redundant-return
       redundant-type-annotation
+      redundant-unsafe
       reserved-primitive-name
       self-assignment
       self-comparison

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.22
 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.2 installed!
+  Milk Tea 0.4.22 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH

data/std/testing.mt

@@ -1,266 +0,0 @@
-# Standard library: testing core (T0 prototype)
-#
-# Minimal, in-language unit-testing surface — see docs/testing.md (§5, T0).
-# A test function returns `Check` and propagates the first failure with `?`:
-#
-#     import std.testing as t
-#
-#     function test_math() -> t.Check:
-#         t.expect_equal_int(2 + 2, 4)?
-#         return t.ok()
-#
-# A hand-written runner (see docs/testing.md §6 for future compiler-driven
-# discovery) calls `record` per test and `summarize` at the end:
-#
-#     function main() -> int:
-#         var stats = t.Stats.create()
-#         stats = t.record(stats, "math", test_math())
-#         return t.summarize(stats)
-
-import std.string as string
-import std.fmt as fmt
-import std.stdio as stdio
-import std.str
-import std.hash
-
-# A test outcome: success carries no meaningful value; failure carries a
-# `Failure`. `Result` is used (not a bespoke variant) so `?` propagation works.
-
-# A failed (or skipped) expectation. `message` is owned and must be released by
-# whoever consumes it (the runner does this in `record`). `is_skip` distinguishes
-# a skip from a real assertion failure.
-public struct Failure:
-    message: string.String
-    is_skip: bool
-
-public type Check = Result[bool, Failure]
-
-
-# Tally of outcomes for a run. Value type; `record` returns an updated copy.
-public struct Stats:
-    passed: int
-    failed: int
-    skipped: int
-
-
-extending Stats:
-    public static function create() -> Stats:
-        return Stats(passed = 0, failed = 0, skipped = 0)
-
-
-# ── Outcome constructors ──────────────────────────────────────────────────
-
-public function ok() -> Check:
-    return Result[bool, Failure].success(value = true)
-
-
-public function fail(message: str) -> Check:
-    return Result[bool, Failure].failure(error = Failure(message = string.String.from_str(message), is_skip = false))
-
-
-public function skip(reason: str) -> Check:
-    return Result[bool, Failure].failure(error = Failure(message = string.String.from_str(reason), is_skip = true))
-
-
-# ── Expectations ──────────────────────────────────────────────────────────
-
-public function expect(condition: bool, message: str) -> Check:
-    if condition:
-        return ok()
-
-    return fail(message)
-
-
-public function expect_true(condition: bool) -> Check:
-    return expect(condition, "expected true")
-
-
-public function expect_false(condition: bool) -> Check:
-    return expect(not condition, "expected false")
-
-
-public function expect_equal_int(actual: int, expected: int) -> Check:
-    if actual == expected:
-        return ok()
-
-    var message = string.String.create()
-    message.append("expected ")
-    fmt.append_int(ref_of(message), expected)
-    message.append(", got ")
-    fmt.append_int(ref_of(message), actual)
-    return Result[bool, Failure].failure(error = Failure(message = message, is_skip = false))
-
-
-public function expect_equal_str(actual: str, expected: str) -> Check:
-    var actual_string = string.String.from_str(actual)
-    var expected_string = string.String.from_str(expected)
-    let same = actual_string.equal(expected_string)
-    actual_string.release()
-    expected_string.release()
-    if same:
-        return ok()
-
-    var message = string.String.create()
-    message.append("expected [")
-    message.append(expected)
-    message.append("], got [")
-    message.append(actual)
-    message.append("]")
-    return Result[bool, Failure].failure(error = Failure(message = message, is_skip = false))
-
-
-public function expect_equal_bool(actual: bool, expected: bool) -> Check:
-    if actual == expected:
-        return ok()
-
-    var message = string.String.create()
-    message.append("expected ")
-    fmt.append_bool(ref_of(message), expected)
-    message.append(", got ")
-    fmt.append_bool(ref_of(message), actual)
-    return Result[bool, Failure].failure(error = Failure(message = message, is_skip = false))
-
-
-public function expect_not_equal_int(actual: int, expected: int) -> Check:
-    if actual != expected:
-        return ok()
-
-    var message = string.String.create()
-    message.append("expected not ")
-    fmt.append_int(ref_of(message), expected)
-    message.append(", got ")
-    fmt.append_int(ref_of(message), actual)
-    return Result[bool, Failure].failure(error = Failure(message = message, is_skip = false))
-
-
-public function expect_not_equal_str(actual: str, expected: str) -> Check:
-    var actual_string = string.String.from_str(actual)
-    var expected_string = string.String.from_str(expected)
-    let same = actual_string.equal(expected_string)
-    actual_string.release()
-    expected_string.release()
-    if not same:
-        return ok()
-
-    var message = string.String.create()
-    message.append("expected not [")
-    message.append(expected)
-    message.append("], got [")
-    message.append(actual)
-    message.append("]")
-    return Result[bool, Failure].failure(error = Failure(message = message, is_skip = false))
-
-
-public function expect_not_equal_bool(actual: bool, expected: bool) -> Check:
-    if actual != expected:
-        return ok()
-
-    var message = string.String.create()
-    message.append("expected not ")
-    fmt.append_bool(ref_of(message), expected)
-    message.append(", got ")
-    fmt.append_bool(ref_of(message), actual)
-    return Result[bool, Failure].failure(error = Failure(message = message, is_skip = false))
-
-
-# Generic equality over any type with a canonical `T.equal` hook: primitives
-# (import std.hash), `str` (import std.str), and user structs that define `equal`
-# (or delegate to std.hash.equal_struct). On failure the actual/expected values
-# are rendered via `std.fmt.format_value`, so `T` must be a primitive or a struct
-# whose fields are themselves `format_value`-renderable.
-public function expect_equal[T](actual: T, expected: T) -> Check:
-    if equal[T](actual, expected):
-        return ok()
-
-    var message = string.String.create()
-    message.append("expected ")
-    fmt.format_value[T](ref_of(message), const_ptr_of(expected))
-    message.append(", got ")
-    fmt.format_value[T](ref_of(message), const_ptr_of(actual))
-    return Result[bool, Failure].failure(error = Failure(message = message, is_skip = false))
-
-
-public function expect_some[T](option: Option[T]) -> Check:
-    if option.is_some():
-        return ok()
-
-    return fail("expected Option.some, got Option.none")
-
-
-public function expect_none[T](option: Option[T]) -> Check:
-    if option.is_none():
-        return ok()
-
-    return fail("expected Option.none, got Option.some")
-
-
-public function expect_null[T](pointer: const_ptr[T]?) -> Check:
-    if pointer == null:
-        return ok()
-
-    return fail("expected null pointer, got non-null")
-
-
-public function expect_not_null[T](pointer: const_ptr[T]?) -> Check:
-    if pointer != null:
-        return ok()
-
-    return fail("expected non-null pointer, got null")
-
-
-public function expect_error[T, E](result: Result[T, E]) -> Check:
-    if result.is_failure():
-        return ok()
-
-    return fail("expected Result.failure, got Result.success")
-
-
-# ── Runner (hand-written; compiler discovery is a later phase) ─────────────
-
-public function record(stats: Stats, name: str, outcome: Check) -> Stats:
-    match outcome:
-        Result.success:
-            var line = string.String.create()
-            line.append("ok   - ")
-            line.append(name)
-            stdio.print_line(line.as_str())
-            line.release()
-            return Stats(passed = stats.passed + 1, failed = stats.failed, skipped = stats.skipped)
-        Result.failure as payload:
-            let failure = payload.error
-            var line = string.String.create()
-            if failure.is_skip:
-                line.append("skip - ")
-            else:
-                line.append("FAIL - ")
-
-            line.append(name)
-            line.append(": ")
-            line.append(failure.message.as_str())
-            stdio.print_line(line.as_str())
-            line.release()
-
-            var owned_message = failure.message
-            owned_message.release()
-
-            if failure.is_skip:
-                return Stats(passed = stats.passed, failed = stats.failed, skipped = stats.skipped + 1)
-
-            return Stats(passed = stats.passed, failed = stats.failed + 1, skipped = stats.skipped)
-
-
-public function summarize(stats: Stats) -> int:
-    var line = string.String.create()
-    line.append("passed=")
-    fmt.append_int(ref_of(line), stats.passed)
-    line.append(" failed=")
-    fmt.append_int(ref_of(line), stats.failed)
-    line.append(" skipped=")
-    fmt.append_int(ref_of(line), stats.skipped)
-    stdio.print_line(line.as_str())
-    line.release()
-
-    if stats.failed > 0:
-        return 1
-
-    return 0