mt-lang 0.3.34 → 0.3.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d0786ef5ca9025e069a44b7ea3915199110e1f2397d294ed81122a308c79e2e
-  data.tar.gz: 42e3fa0077192377fa7da61cea865fd04e8ef49d66343c71a1bd5e2e1caa8b59
+  metadata.gz: 952280dd2ad14bc3b5751fc7e8a3d29b39363293b1436cc1b3b546c31c938427
+  data.tar.gz: e0bdf3468681b07914143c32b0b9cc2470cdbeaf55cf81994186003dc406261b
 SHA512:
-  metadata.gz: fd4a874279ff48b7d0f1de8baf092e92e01ede8a4c969133855c9dd9c9f061490c11ff29dfc24905466fe1df56d1d53a86a5c156ce1cbe5efeed60d78f5a21e8
-  data.tar.gz: 30bb123ddb1939f7694c62dae186152b8f592d78826e7b4aa416c6a010202d07bda5474b72014114d8064b7168ff02b6b7dd252a8b7d007d9b9bcae8b31b4786
+  metadata.gz: 9dcf6f6c955f1428b5374315782fda121669ae3c12a8c84d683205cb44bb4ca7903465e70447860e89c0753695f01af513903e93b82987838fa724be19fc7b2f
+  data.tar.gz: 67c259de17bdd81a4f5785d7dbe05cf39ab959ea51c1f27ed2b05a516ed97ce91a4b2291aa415e0abaa695337f1fc1825ead4acdfceb480a9be4db3cd3a24dd4

data/README.md

@@ -939,7 +939,7 @@ See module source for full method surface. Iterator forms:
 
 Text categories:
 
-- `str` -> string view. The `+` operator concatenates two `str` values, allocating a new heap-backed string. For loops or repeated concatenation, prefer `string.String` for amortized performance.
+- `str` -> string view. The `+` operator concatenates two `str` values into a per-thread scratch buffer (no heap allocation), returning a borrowed `str`; the result stays valid while cumulative concatenations on that thread remain within the scratch buffer budget. For loops or repeated concatenation, prefer `string.String` for amortized building.
 - `cstr` -> C ABI string
 - `str_buffer[N]` -> fixed-capacity mutable UTF-8 text buffer
 
@@ -959,7 +959,7 @@ Format strings:
 
 - `f"count=#{count}"` has type `str`.
 - Allowed interpolations: `str`, `cstr`, `bool`, numeric primitives, integer-backed enums and flags, plus types implementing `format_len() -> ptr_uint` and `append_format(output: ref[std.string.String]) -> void`.
-- `f"..."` is a borrowed temporary on the stack — it cannot be returned from a function as `str`. Use `std.fmt.format(f"...")` returning `string.String` when ownership must escape.
+- Dynamic `f"..."` expressions build into a heap-backed temporary that the compiler releases after use. A dynamic `f"..."` may be returned from a function (or stored in a `str` local): ownership of that buffer transfers to the caller. `std.fmt.format(f"...")` returns an owned `string.String` when you want explicit owned-text lifetime management.
 - Float and double interpolations support `:.N` precision.
 - Integer primitive and integer-backed enum/flags interpolations support `:x` (lowercase hex) and `:X` (uppercase hex).
 - Integer primitive and integer-backed enum/flags interpolations support `:o` / `:O` (octal) and `:b` / `:B` (binary).

data/docs/index.html

@@ -1262,7 +1262,7 @@ let d: dyn[Drawable] = adapt[Drawable](ref_of(entity))</code></pre>
       <tr><td><code>ptr_int</code> <code>ptr_uint</code></td><td>Pointer-sized integers</td></tr>
       <tr><td><code>float</code> <code>double</code></td><td>Floating-point</td></tr>
       <tr><td><code>void</code></td><td>No value</td></tr>
-      <tr><td><code>str</code></td><td>UTF-8 string view (borrowed). The <code>+</code> operator concatenates two <code>str</code> values, allocating a new heap-backed string.</td></tr>
+      <tr><td><code>str</code></td><td>UTF-8 string view (borrowed). The <code>+</code> operator concatenates two <code>str</code> values into a per-thread scratch buffer (no allocation); the result is valid while the scratch budget lasts.</td></tr>
       <tr><td><code>cstr</code></td><td>NUL-terminated C string</td></tr>
       <tr><td><code>vec2</code> <code>vec3</code> <code>vec4</code></td><td>Float vectors with <code>.x .y .z .w</code></td></tr>
       <tr><td><code>ivec2</code> <code>ivec3</code> <code>ivec4</code></td><td>Integer vectors</td></tr>
@@ -1871,7 +1871,7 @@ function field_equal[T](a: const_ptr[T], b: const_ptr[T]) -&gt; bool:
   <div class="table-wrap">
     <table class="attr-table">
       <tr><th>Type</th><th>Ownership</th><th>Use Case</th></tr>
-      <tr><td><code>str</code></td><td>Borrowed</td><td>Read-only UTF-8 view (literals, format strings, slicing)</td></tr>
+      <tr><td><code>str</code></td><td>Borrowed</td><td>Read-only UTF-8 view (literals, format strings, slicing); a stored or returned dynamic format string carries its own heap buffer</td></tr>
       <tr><td><code>cstr</code></td><td>Borrowed</td><td>NUL-terminated C ABI string (<code>c"hello"</code>)</td></tr>
       <tr><td><code>str_buffer[N]</code></td><td>Owned (stack)</td><td>Fixed-capacity mutable UTF-8 builder</td></tr>
       <tr><td><code>std.string.String</code></td><td>Owned (heap)</td><td>Growable owned text via <code>fmt.format(f"...")</code></td></tr>
@@ -1889,9 +1889,9 @@ let info = f"value=#{pi:.4}"
 ## Hex format for ints
 let hex = f"address=#{ptr_value:x}"
 
-## Owned text (escape stack lifetime)
+## Owned text with explicit release
 import std.fmt
-let owned = fmt.format(f"count=#{count}")  ## -> string.String</code></pre>
+let owned = fmt.format(f"count=#{count}")  ## -> string.String (call .release())</code></pre>
 </div>
   <p>Interpolated expressions must be <code>str</code>, <code>cstr</code>, <code>bool</code>, a numeric primitive, an integer-backed enum or flags type, or a type implementing <code>format_len()</code> and <code>append_format()</code> (custom formatting hooks). The compiler lowers <code>fmt.format(f"...")</code>, <code>str_buffer.append_format(f"...")</code>, and <code>string.String.append_format(f"...")</code> directly to the formatted output without an intermediate allocation.</p>
 
@@ -2242,7 +2242,7 @@ function attach(window: ref[Window]) -> Result[void, EventError]:
       <tr><td><code>std.gzip</code> <code>std.tar</code></td><td>Compression</td></tr>
       <tr><td><code>std.sync</code> <code>std.thread</code> <code>std.jobs</code></td><td>Concurrency</td></tr>
       <tr><td><code>std.fsm</code> <code>std.goap</code> <code>std.behavior_tree</code></td><td>AI / State machines</td></tr>
-      <tr><td><code>std.cell</code></td><td>Shared mutable cell allocation</td></tr>
+      <tr><td><code>std.box</code></td><td>Explicit single-value heap storage for shared mutable state</td></tr>
     </table>
   </div>
 </section>

data/docs/language-design.md

@@ -28,7 +28,7 @@ The output target is beautiful C. The generated C should be readable enough that
 - No macro system that rewrites arbitrary ASTs
 - No garbage collector
 - No implicit conversions between unrelated primitive types
-- No user-invisible allocation for strings, collections, ordinary values, or method calls. Capturing a `proc` may allocate a ref-counted closure environment as part of proc value semantics; owned text and other storage use explicit allocating surfaces.
+- No user-invisible allocation for collections, ordinary values, or method calls. Capturing a `proc` may allocate a ref-counted closure environment as part of proc value semantics. Dynamic format strings are the one text case that builds a heap-backed temporary, released after use (see the text-construction rule in §1); other owned text and storage use explicit allocating surfaces.
 
 ## Design rules
 
@@ -38,7 +38,7 @@ If code allocates, takes an address, dereferences a raw pointer, performs an FFI
 
 FFI visibility belongs at the declaration site. Raw `external` files expose exact ABI types. Imported foreign declarations may project those raw types into ordinary Milk Tea types, but the projection rule, temporary-storage rule, and ownership rule must be declared there instead of repeated at every call site.
 
-The same rule applies to text construction. Plain string literals and format string literals are borrowed `str` values. The `+` operator on `str` allocates a new heap-backed `str` — the one everyday convenience that does allocate. For loops or amortized building, `string.String` and `str_buffer[N]` remain the explicit surfaces with visible cost. Any other surface that builds owned text must say so explicitly, for example `std.fmt.format(f"...")` when ownership must escape.
+The same rule applies to text construction. Plain string literals are borrowed `str` values. A dynamic format string `f"..."` builds into a heap-backed temporary that the compiler releases after the surrounding statement; returning it (or storing it in a `str` local) transfers ownership of that buffer to the caller. The `+` operator on `str` concatenates into a per-thread scratch buffer without allocating — the result is a borrowed `str` valid until that buffer's budget is exhausted. For loops or amortized building, and whenever ownership should stay explicit and controllable, `string.String` and `str_buffer[N]` remain the explicit surfaces with visible cost; `std.fmt.format(f"...")` is the explicit owned-text path returning a `string.String`.
 
 ### 2. C is the ABI ground truth
 
@@ -762,7 +762,7 @@ Built-in operators should match familiar C behavior where possible:
 
 No user-defined operator overloading.
 
-The `+` operator also concatenates two `str` values, allocating a new heap-backed string; `cstr` values are not concatenable. This is the one operator exception to the arithmetic rules, and it is described in the text-construction rule under Design rules §1.
+The `+` operator also concatenates two `str` values into a per-thread scratch buffer, returning a borrowed `str`; `cstr` values are not concatenable. This is the one operator exception to the arithmetic rules, and it is described in the text-construction rule under Design rules §1.
 
 Built-in vector, matrix, and quaternion types support component-wise arithmetic with the standard operators:
 

data/docs/language-manual.md

@@ -1072,7 +1072,7 @@ Rules:
 11. `+`, `-`
 12. `*`, `/`, `%`
 
-The `+` operator also concatenates two `str` operands, producing a new heap-backed `str` (§2.3). It does not concatenate `cstr` or mixed `str`/`cstr` operands.
+The `+` operator also concatenates two `str` operands into a per-thread scratch buffer, producing a borrowed `str` (no heap allocation) whose validity is bounded by the scratch buffer budget (§2.3). It does not concatenate `cstr` or mixed `str`/`cstr` operands.
 
 ### 5.4 Assignment operators
 

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/bindings/bindgen/type_mapper.rb

@@ -22,8 +22,14 @@ module MilkTea
                 "cstr"
               else
                 pointee = pointer_candidate.sub(/\s*\*\z/, "")
-                pointer_name = top_level_const_qualified?(pointee) ? "const_ptr" : "ptr"
-                "#{pointer_name}[#{map_c_type(pointee, context:)}]"
+                if function_type_typedef?(pointee)
+                  # `Name *` where Name is a function-type typedef is a function
+                  # pointer, which is exactly what the `fn` type already is.
+                  map_c_type(pointee, context:)
+                else
+                  pointer_name = top_level_const_qualified?(pointee) ? "const_ptr" : "ptr"
+                  "#{pointer_name}[#{map_c_type(pointee, context:)}]"
+                end
               end
             else
               unqualified = strip_qualifiers(normalized)
@@ -515,6 +521,10 @@ module MilkTea
           qual_type.end_with?("*")
         end
 
+        def function_type_typedef?(qual_type)
+          @function_type_typedef_names.include?(strip_qualifiers(qual_type))
+        end
+
         def c_string_pointer?(qual_type)
           pointee = qual_type.sub(/\s*\*\z/, "")
           unqualified = strip_qualifiers(pointee)

data/lib/milk_tea/bindings/bindgen.rb

@@ -147,6 +147,11 @@ module MilkTea
         @visible_typedef_names = top_level_nodes.filter_map do |node|
           node["name"] if node["kind"] == "TypedefDecl" && allowed_declaration_name?(node["name"])
         end
+        @function_type_typedef_names = top_level_nodes.filter_map do |node|
+          if node["kind"] == "TypedefDecl" && allowed_declaration_name?(node["name"]) && extract_function_proto(node) && !function_pointer_type?(type_qual_type(node))
+            node["name"]
+          end
+        end
         build_alias_maps(top_level_nodes)
 
         declarations = []

data/lib/milk_tea/core/c_backend/aggregate_utils.rb

@@ -139,6 +139,8 @@ module MilkTea
           end
         when Types::Task
           [task_type_name(type)]
+        when Types::Dyn
+          [dyn_type_name(type)]
         when Types::Proc
           [proc_type_name(type)]
         when Types::GenericInstance
@@ -153,6 +155,8 @@ module MilkTea
           end
         when Types::Function
           []
+        when Types::Tuple
+          [tuple_type_name(type)]
         when Types::Struct, Types::StructInstance, Types::Union, Types::Variant, Types::VariantInstance, Types::Event, Types::Subscription
           [named_type_c_name(type)]
         when Types::VariantArmPayload

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

@@ -347,7 +347,22 @@ module MilkTea
       def emit_address_of_operand(expression)
         return emit_expression(expression.operand) if expression.is_a?(IR::Unary) && expression.operator == "*"
 
-        "&#{wrap_expression(expression)}"
+        return "&#{wrap_expression(expression)}" if c_expression_lvalue?(expression)
+
+        "&(#{c_type(expression.type)}[1]){ #{emit_expression(expression)} }[0]"
+      end
+
+      def c_expression_lvalue?(expression)
+        case expression
+        when IR::Name, IR::CheckedIndex, IR::CheckedSpanIndex, IR::AggregateLiteral, IR::ArrayLiteral, IR::VariantLiteral, IR::ZeroInit
+          true
+        when IR::Member, IR::Index
+          c_expression_lvalue?(expression.receiver)
+        when IR::Unary
+          expression.operator == "*"
+        else
+          false
+        end
       end
 
       def emit_cast_operand(expression)
@@ -464,7 +479,12 @@ module MilkTea
       def emit_addressof_field_initializer(field_type, value)
         c_type_name = named_type_c_name(field_type)
         inner = value.expression
-        "((#{c_type_name}*)memcpy(malloc(sizeof(#{c_type_name})), &(#{emit_expression(inner)}), sizeof(#{c_type_name})))"
+        source = if c_expression_lvalue?(inner)
+          "&(#{emit_expression(inner)})"
+        else
+          "&(#{c_type(field_type)}[1]){ #{emit_expression(inner)} }[0]"
+        end
+        "((#{c_type_name}*)memcpy(malloc(sizeof(#{c_type_name})), #{source}, sizeof(#{c_type_name})))"
       end
 
       def emit_cyclic_array_initializer(field_type, value)
@@ -479,8 +499,10 @@ module MilkTea
         init = emit_initializer(value)
         source_expr = if init.start_with?("{")
           "&(#{c_type(field_type)})#{init}"
-        else
+        elsif c_expression_lvalue?(value)
           "&(#{init})"
+        else
+          "&(#{c_type(field_type)}[1]){ #{init} }[0]"
         end
         "((#{field_c_name}*)memcpy(malloc(sizeof(#{field_c_name})), #{source_expr}, sizeof(#{field_c_name})))"
       end

data/lib/milk_tea/core/c_backend/reinterpret.rb

@@ -116,13 +116,13 @@ module MilkTea
         return false if expression.expression.type.is_a?(Types::Null)
 
         c_type(expression.target_type) == c_type(expression.expression.type)
-      rescue StandardError
+      rescue CBackendError
         false
       end
 
       def identity_reinterpret?(target_type, source_type)
         c_type(target_type) == c_type(source_type)
-      rescue StandardError
+      rescue CBackendError
         false
       end
 

data/lib/milk_tea/core/c_backend/runtime_helpers.rb

@@ -104,7 +104,17 @@ module MilkTea
       def emit_struct_equality_helpers
         struct_decls_by_linkage = (emitted_aggregate_structs + collect_generic_struct_decls).each_with_object({}) { |decl, map| map[decl.linkage_name] = decl }
         struct_equality_types
-          .filter_map { |type| type.is_a?(Types::VariantArmPayload) ? type : struct_decls_by_linkage[named_type_c_name(type)] }
+          .filter_map do |type|
+            if type.is_a?(Types::VariantArmPayload)
+              type
+            elsif struct_decls_by_linkage.key?(named_type_c_name(type))
+              struct_decls_by_linkage[named_type_c_name(type)]
+            elsif type.is_a?(Types::Struct)
+              # External structs (raw ABI bindings) are not lowered into
+              # @program.structs, but their field layout is still known.
+              type
+            end
+          end
           .flat_map { |decl_or_type| emit_struct_equality_helper(decl_or_type) }
       end
 
@@ -112,11 +122,14 @@ module MilkTea
         if struct_decl_or_type.is_a?(IR::StructDecl)
           outer_c = struct_decl_or_type.linkage_name
           fields = struct_decl_or_type.fields
-        else
+        elsif struct_decl_or_type.is_a?(Types::VariantArmPayload)
           payload = struct_decl_or_type
           outer_c = named_type_c_name(payload)
           arm_fields = payload.variant_type.arm(payload.arm_name) || {}
           fields = arm_fields.map { |name, field_type| IR::Field.new(name:, type: field_type) }
+        else
+          outer_c = named_type_c_name(struct_decl_or_type)
+          fields = struct_decl_or_type.fields.map { |name, field_type| IR::Field.new(name:, type: field_type) }
         end
 
         lines = ["static bool mt_struct_eq_#{outer_c}(struct #{outer_c} left, struct #{outer_c} right) {"]

data/lib/milk_tea/core/c_backend/type_collectors.rb

@@ -266,6 +266,10 @@ module MilkTea
         simd_types = []
         visited = {}
 
+        all_emitted_top_level_values.each do |value|
+          collect_simd_type(value.type, simd_types, visited)
+        end
+
         emitted_functions.each do |function|
           collect_simd_type(function.return_type, simd_types, visited)
           function.params.each do |param|
@@ -280,6 +284,16 @@ module MilkTea
           end
         end
 
+        @program.unions.each do |union_decl|
+          union_decl.fields.each do |field|
+            collect_simd_type(field.type, simd_types, visited)
+          end
+        end
+
+        each_variant_arm_field_type do |field_type|
+          collect_simd_type(field_type, simd_types, visited)
+        end
+
         simd_types.uniq
       end
 
@@ -299,9 +313,32 @@ module MilkTea
         return unless type
         return if visited[type]
 
-        if type.is_a?(Types::Simd)
+        visited[type] = true
+
+        case type
+        when Types::Simd
           simd_types << type
-          visited[type] = true
+        when Types::Nullable
+          collect_simd_type(type.base, simd_types, visited)
+        when Types::GenericInstance
+          type.arguments.each do |argument|
+            collect_simd_type(argument, simd_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
+          end
+        when Types::Function
+          type.params.each do |param|
+            collect_simd_type(param.type, simd_types, visited)
+          end
+          collect_simd_type(type.return_type, simd_types, visited)
+        when Types::Struct, Types::Union
+          type.fields.each_value do |field_type|
+            collect_simd_type(field_type, simd_types, visited)
+          end
+        when Types::Variant
+          type.arm_names.each do |arm_name|
+            type.arm(arm_name).each_value do |field_type|
+              collect_simd_type(field_type, simd_types, visited)
+            end
+          end
         end
       end
 

data/lib/milk_tea/core/c_backend.rb

@@ -27,6 +27,18 @@ module MilkTea
     def code
       "backend/internal"
     end
+
+    def to_diagnostic(path: nil)
+      Diagnostic.new(
+        path: @path || path,
+        line: @line,
+        column: @column,
+        length: nil,
+        code: code,
+        message: message,
+        severity: :error,
+      )
+    end
   end
 
   class CBackend

data/lib/milk_tea/core/compile_time.rb

@@ -6,16 +6,27 @@ module MilkTea
   module CompileTime
     Layout = ::MilkTea::Types::Layout
 
-    class ReturnValue < StandardError
-      attr_reader :value
+    # Carries the value of a `return` statement out of the block evaluator as
+    # an ordinary value instead of an exception; callers unwrap it when present.
+    ReturnOutcome = Data.define(:value)
 
-      def initialize(value)
-        @value = value
-        super("return #{value.inspect}")
+    class Error < StandardError
+      def code
+        "compile_time/error"
       end
-    end
 
-    class Error < StandardError; end
+      def to_diagnostic(path: nil)
+        Diagnostic.new(
+          path: path,
+          line: nil,
+          column: nil,
+          length: nil,
+          code: code,
+          message: message,
+          severity: :error,
+        )
+      end
+    end
 
     def self.evaluate(expression, resolve_identifier:, resolve_member_access:, resolve_type_ref: nil, resolve_call: nil)
       Evaluator.new(
@@ -78,6 +89,10 @@ module MilkTea
           nil
         when AST::ExpressionList
           expression.elements.filter_map { |element| evaluate(element) }
+        when AST::RangeExpr
+          start_val = evaluate(expression.start_expr)
+          end_val = evaluate(expression.end_expr)
+          start_val.is_a?(Integer) && end_val.is_a?(Integer) ? (start_val...end_val).to_a : nil
         when AST::IntegerLiteral, AST::FloatLiteral, AST::BooleanLiteral
           expression.value
         when AST::StringLiteral
@@ -184,6 +199,8 @@ module MilkTea
         right = evaluate(expression.right)
 
         case expression.operator
+        when ".."
+          left.is_a?(Integer) && right.is_a?(Integer) ? (left...right).to_a : nil
         when "=="
           CompileTime.equality_result(left, right)
         when "!="
@@ -243,35 +260,45 @@ module MilkTea
         result = nil
 
         statements.each do |statement|
-          case statement
-          when AST::LocalDecl
-            result = evaluate_local_decl(statement, scopes:)
-          when AST::ReturnStmt
-            value = statement.value ? evaluate_expression(statement.value, scopes:) : nil
-            raise ReturnValue.new(value)
-          when AST::WhileStmt
-            result = evaluate_while(statement, scopes:)
-          when AST::ForStmt
-            result = evaluate_for(statement, scopes:)
-          when AST::Assignment
-            result = evaluate_assignment(statement, scopes:)
-          when AST::IfStmt
-            result = evaluate_if(statement, scopes:)
-          when AST::ExpressionStmt
-            evaluate_expression(statement.expression, scopes:)
-          when AST::PassStmt, AST::BreakStmt, AST::ContinueStmt
-            # no-op at compile time
-          when AST::EmitStmt
-            # evaluated during lowering
-            result = nil
-          else
-            result = nil
-          end
+          outcome = evaluate_statement(statement, scopes:)
+          return outcome if outcome.is_a?(ReturnOutcome)
+
+          result = outcome
         end
 
         result
       end
 
+      def evaluate_statement(statement, scopes:)
+        case statement
+        when AST::LocalDecl
+          evaluate_local_decl(statement, scopes:)
+        when AST::ReturnStmt
+          value = statement.value ? evaluate_expression(statement.value, scopes:) : nil
+          ReturnOutcome.new(value)
+        when AST::WhileStmt
+          evaluate_while(statement, scopes:)
+        when AST::ForStmt
+          evaluate_for(statement, scopes:)
+        when AST::MatchStmt
+          evaluate_match(statement, scopes:)
+        when AST::Assignment
+          evaluate_assignment(statement, scopes:)
+        when AST::IfStmt
+          evaluate_if(statement, scopes:)
+        when AST::ExpressionStmt
+          evaluate_expression(statement.expression, scopes:)
+        when AST::PassStmt, AST::BreakStmt, AST::ContinueStmt
+          # no-op at compile time
+          nil
+        when AST::EmitStmt
+          # emitted declarations are collected during lowering
+          nil
+        else
+          nil
+        end
+      end
+
       def evaluate_expression(expression, scopes:)
         case expression
         when AST::Identifier
@@ -304,11 +331,34 @@ module MilkTea
         value = evaluate_expression(assignment.value, scopes:)
         case assignment.target
         when AST::Identifier
+          if assignment.operator != "="
+            current = @variables[assignment.target.name]
+            value = apply_compile_time_binary(assignment.operator.chomp("="), current, value)
+          end
           @variables[assignment.target.name] = value
         end
         value
       end
 
+      def apply_compile_time_binary(operator, left, right)
+        case operator
+        when "+" then left.is_a?(Numeric) && right.is_a?(Numeric) ? left + right : nil
+        when "-" then left.is_a?(Numeric) && right.is_a?(Numeric) ? left - right : nil
+        when "*" then left.is_a?(Numeric) && right.is_a?(Numeric) ? left * right : nil
+        when "/" then left.is_a?(Numeric) && right.is_a?(Numeric) && !zero_numeric?(right) ? left / right : nil
+        when "%" then left.is_a?(Integer) && right.is_a?(Integer) && !right.zero? ? left % right : nil
+        when "&" then left.is_a?(Integer) && right.is_a?(Integer) ? left & right : nil
+        when "|" then left.is_a?(Integer) && right.is_a?(Integer) ? left | right : nil
+        when "^" then left.is_a?(Integer) && right.is_a?(Integer) ? left ^ right : nil
+        when "<<" then left.is_a?(Integer) && right.is_a?(Integer) ? left << right : nil
+        when ">>" then left.is_a?(Integer) && right.is_a?(Integer) ? left >> right : nil
+        end
+      end
+
+      def zero_numeric?(value)
+        (value.is_a?(Integer) && value.zero?) || (value.is_a?(Float) && value.zero?)
+      end
+
       def evaluate_while(statement, scopes:)
         result = nil
         iterations = 0
@@ -320,15 +370,8 @@ module MilkTea
           break unless CompileTime.boolean_value?(condition)
 
           statement.body.each do |body_stmt|
-            case body_stmt
-            when AST::ReturnStmt
-              value = body_stmt.value ? evaluate_expression(body_stmt.value, scopes:) : nil
-              raise ReturnValue.new(value)
-            when AST::Assignment
-              evaluate_assignment(body_stmt, scopes:)
-            when AST::ExpressionStmt
-              evaluate_expression(body_stmt.expression, scopes:)
-            end
+            outcome = evaluate_statement(body_stmt, scopes:)
+            return outcome if outcome.is_a?(ReturnOutcome)
           end
           iterations += 1
         end
@@ -348,19 +391,8 @@ module MilkTea
         iterable.each do |element|
           @variables[loop_var_name] = element
           statement.body.each do |body_stmt|
-            case body_stmt
-            when AST::ReturnStmt
-              value = body_stmt.value ? evaluate_expression(body_stmt.value, scopes:) : nil
-              raise ReturnValue.new(value)
-            when AST::Assignment
-              evaluate_assignment(body_stmt, scopes:)
-            when AST::ExpressionStmt
-              evaluate_expression(body_stmt.expression, scopes:)
-            when AST::IfStmt
-              result = evaluate_if(body_stmt, scopes:)
-            when AST::WhileStmt
-              result = evaluate_while(body_stmt, scopes:)
-            end
+            outcome = evaluate_statement(body_stmt, scopes:)
+            return outcome if outcome.is_a?(ReturnOutcome)
           end
         end
 
@@ -372,15 +404,8 @@ module MilkTea
           condition = evaluate_expression(branch.condition, scopes:)
           if CompileTime.boolean_value?(condition) && condition
             branch.body.each do |body_stmt|
-              case body_stmt
-              when AST::ReturnStmt
-                value = body_stmt.value ? evaluate_expression(body_stmt.value, scopes:) : nil
-                raise ReturnValue.new(value)
-              when AST::Assignment
-                evaluate_assignment(body_stmt, scopes:)
-              when AST::ExpressionStmt
-                evaluate_expression(body_stmt.expression, scopes:)
-              end
+              outcome = evaluate_statement(body_stmt, scopes:)
+              return outcome if outcome.is_a?(ReturnOutcome)
             end
             return condition
           end
@@ -388,15 +413,26 @@ module MilkTea
 
         if statement.else_body
           statement.else_body.each do |body_stmt|
-            case body_stmt
-            when AST::ReturnStmt
-              value = body_stmt.value ? evaluate_expression(body_stmt.value, scopes:) : nil
-              raise ReturnValue.new(value)
-            when AST::Assignment
-              evaluate_assignment(body_stmt, scopes:)
-            when AST::ExpressionStmt
-              evaluate_expression(body_stmt.expression, scopes:)
+            outcome = evaluate_statement(body_stmt, scopes:)
+            return outcome if outcome.is_a?(ReturnOutcome)
+          end
+        end
+
+        nil
+      end
+
+      def evaluate_match(statement, scopes:)
+        scrutinee = evaluate_expression(statement.expression, scopes:)
+        return nil unless scrutinee
+
+        statement.arms.each do |arm|
+          wildcard = arm.pattern.is_a?(AST::Identifier) && arm.pattern.name == "_"
+          if wildcard || CompileTime.equality_result(scrutinee, evaluate_expression(arm.pattern, scopes:)) == true
+            arm.body.each do |body_stmt|
+              outcome = evaluate_statement(body_stmt, scopes:)
+              return outcome if outcome.is_a?(ReturnOutcome)
             end
+            return scrutinee
           end
         end
 
@@ -445,9 +481,8 @@ module MilkTea
             initial_vars[param.name] = arg_value
           end
           ctx = BlockContext.new(@checker, initial_variables: initial_vars)
-          ctx.evaluate_block(func.ast.body, scopes:)
-        rescue ReturnValue => e
-          e.value
+          result = ctx.evaluate_block(func.ast.body, scopes:)
+          result.is_a?(ReturnOutcome) ? result.value : result
         end
       end
 
@@ -506,7 +541,7 @@ module MilkTea
       end
 
       def self.core_member_handles(type)
-        type.members.map { |name, value| Types::MemberHandle.new(nil, name, value) }
+        type.members.map { |name| Types::MemberHandle.new(nil, name, type.member_value(name)) }
       end
 
       def self.core_evaluate_type_returning(

data/lib/milk_tea/core/lexer.rb

@@ -26,6 +26,18 @@ module MilkTea
     def code
       "lex/error"
     end
+
+    def to_diagnostic(path: nil)
+      Diagnostic.new(
+        path: @path || path,
+        line: @line,
+        column: @column,
+        length: nil,
+        code: code,
+        message: message,
+        severity: :error,
+      )
+    end
   end
 
   class Lexer