mt-lang 0.2.22 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2ffe49a95d73789f46660b0bf1ccdd0e8cca26846d19a33352751c93371531a
-  data.tar.gz: 75be2b9035d9271b691849b98769073d875f3a81aeb656feafab63b5998ca371
+  metadata.gz: e7b3cb1fb6603adc1eae75fca276b3cbe83fa5daac424d70dda2386200c541da
+  data.tar.gz: ccd1d4f1d2bfb4d19be13053a90445be1c6aedc0785d6e089f43f4ad650e72d9
 SHA512:
-  metadata.gz: a52f4fe111b80f9ea19dd24b1df46356a1450134a3bd01fce0abd50d482e4b670ad9462d4884384a09447ab1483f6c49e37175191da86abb8143fc7446109f5a
-  data.tar.gz: 75be516db3258f9c705fcf6d9f4d3a84995e2fb2c91dddbc8899cf7ac3f79fdc1054b7068567654aef88c29637e5dff136894b1ceed50b4436354525e3298d53
+  metadata.gz: 9b378bb8cc0e369b7b9f318821c4c5c287135e4e88c75bef3e26944935b4a3679d128f5e273b3de2851fe16dd3af38065fd74ceba23d334ef67a8f716cb73319
+  data.tar.gz: 39c93ea971b8092f9222a1ded6a01512087f232dcb431868227708897cac5defd72ca1b30fa180113a43688aebd5aad2983629b2ad7cc3314d0fb583c3418093

data/README.md

@@ -1,4 +1,4 @@
-# Milk Tea
+# Milk Tea (Simple Game) Programming Language
 
 A statically typed, indentation-based systems language for games.
 Compiles to readable C. Safe by default, explicit by design.
@@ -360,10 +360,20 @@ Ordinary functions:
 
 - Parameters must be typed.
 - Parameters are non-rebindable.
+- Parameters may include default values using `name: type = default_expr`. All required parameters must appear before defaulted parameters. Default calls are resolved at compile time by inlining the expression at each call site that omits the argument. Defaults are not supported on `external function` or `foreign function`.
 - Return type defaults to `void` if omitted.
 - Generic functions are supported.
 - Generic function and method type parameters may use `implements` constraints.
 
+```mt
+function configure(host: str, port: int = 8080, debug: bool = false) -> void:
+    pass
+
+configure("localhost")                     # port=8080, debug=false
+configure("localhost", port = 3000)        # debug=false
+configure(host = "remote", debug = true)   # port=8080
+```
+
 `const function`:
 
 A `const function` is evaluable at compile time. Its body follows the same restrictions as a block-bodied `const`. When called from a compile-time context (`const`, `when`, `inline if`, `inline for`), the call is constant-folded:
@@ -476,6 +486,17 @@ let label = match code:
     _: "other"
 ```
 
+Integer match arms also support range patterns via `start..end`:
+
+```mt
+let tier = match score:
+    0..10: "low"
+    11..50: "mid"
+    _: "high"
+```
+
+Range arms are refutable — they do not count toward exhaustiveness — and require `_`.
+
 `match` rules:
 
 - Enum and variant matches must be exhaustive unless `_` is present.
@@ -713,6 +734,7 @@ Native type operators:
 - Vectors (`vecN`/`ivecN`): `+`, `-`, `*` (component-wise) with same-type vectors; `*`, `/` with scalar; unary `-`
 - Matrices (`matN`): `+`, `-` with same-type matrices; `*`, `/` with scalar; unary `-`
 - Quaternions (`quat`): `+`, `-`, `*` (component-wise) with same-type quaternions; unary `-`
+- SIMD vectors (`simd[T, N]`): `+`, `-`, `*`, `/` (component-wise same-type or scalar), `%`, `&`, `|`, `^`, `~` (integer lanes), `<<`, `>>` (integer lanes, scalar shift), unary `-`/`~` (integer lanes for `~`)
 
 ## 10. Type System
 
@@ -762,6 +784,7 @@ Type constructors:
 - `fn(params...) -> R`
 - `proc(params...) -> R`
 - `SoA[T, N]` — Structure-of-Arrays: each struct field becomes a separate array of length `N`; access `soa[i].field` reads from column `field` at row `i`
+- `simd[T, N]` — SIMD vector: `N` numeric lanes (128 or 256 bits). Component-wise `+` `-` `*` `/` `%` `&` `|` `^` `~` `<<` `>>`. Lane access via `[i]` (compile-time index). Lowers to GCC/Clang vector extensions for portable x86/ARM vector code.
 - `dyn[InterfaceName]` — runtime interface value (fat pointer: `{ void* data, void* vtable }`). Constructed via `adapt[Interface](value: ref[T])`. @see §6.
 - `atomic[T]` — atomic value for lock-free concurrent access. `T` must be a primitive integer or `bool`. Methods: `load() -> T`, `store(value: T)`, `add(value: T) -> T`, `sub(value: T) -> T`, `exchange(value: T) -> T`. All operations use sequential consistency. Lowers to C11 `_Atomic T` with `__atomic_*` builtins.
 - `(T, U)` — tuple type. Positional fields auto-named `_0`, `_1`. Named fields use `(x = T, y = U)`. Copy by value, returns supported.

data/docs/index.html

@@ -1272,6 +1272,7 @@ let q = quat(x = 0.0, y = 0.0, z = 0.0, w = 1.0)</code></pre>
       <tr><td><code>fn(params...) -&gt; R</code></td><td>Function pointer type</td></tr>
       <tr><td><code>proc(params...) -&gt; R</code></td><td>Closure type (value captures)</td></tr>
       <tr><td><code>SoA[T, N]</code></td><td>Structure-of-Arrays: fields become separate arrays</td></tr>
+      <tr><td><code>simd[T, N]</code></td><td>SIMD vector: N numeric lanes (128/256-bit), GCC vector extensions</td></tr>
       <tr><td><code>dyn[Interface]</code></td><td>Runtime interface value (fat pointer)</td></tr>
       <tr><td><code>atomic[T]</code></td><td>Atomic value for lock-free concurrent access</td></tr>
       <tr><td><code>(T, U)</code></td><td>Tuple type</td></tr>
@@ -2529,7 +2530,7 @@ const TYPES = new Set([
   'bool','byte','short','int','long','ubyte','ushort','uint','ulong',
   'char','ptr_int','ptr_uint','float','double','void',
   'str','cstr','vec2','vec3','vec4','ivec2','ivec3','ivec4',
-  'mat3','mat4','quat','ptr','span','array','SoA',
+  'mat3','mat4','quat','ptr','span','array','SoA','simd',
   'Option','Result','Task','dyn','ref','const_ptr','own','str_buffer','proc',
   'field_handle','member_handle','callable_handle','attribute_handle',
   'EventError','Subscription','atomic',

data/docs/language-design.md

@@ -561,6 +561,7 @@ Notes:
 ```mt
 array[T, N]      # fixed-size array
 SoA[T, N]        # Structure-of-Arrays: flatten struct fields into separate arrays
+simd[T, N]       # SIMD vector: N numeric lanes, 128/256-bit, lowers to GCC vector extensions
 str_buffer[N]   # fixed-capacity mutable UTF-8 text buffer
 ptr[T]           # raw pointer
 span[T]          # pointer + length view
@@ -771,6 +772,7 @@ Built-in vector, matrix, and quaternion types support component-wise arithmetic
 - Vectors (`vecN`/`ivecN`): `+`, `-`, `*` (component-wise same-type); `*`, `/` (scalar); unary `-`
 - Matrices (`matN`): `+`, `-` (component-wise same-type); `*`, `/` (scalar); unary `-`
 - Quaternions (`quat`): `+`, `-`, `*` (component-wise same-type); unary `-`
+- SIMD vectors (`simd[T, N]`): `+`, `-`, `*`, `/` (component-wise same-type); `+`, `-`, `*`, `/` (scalar, when scalar matches element type); `%`, `&`, `|`, `^`, `~` (integer element types only); `<<`, `>>` (integer element types, shift-amount is scalar int); unary `-`, `~`
 
 ### Casts
 

data/docs/language-manual.md

@@ -426,6 +426,19 @@ function add(a: int, b: int) -> int:
     return a + b
 ```
 
+Parameters may include default values using `= expr` after the type annotation. All required parameters must appear before any defaulted parameter. The default expression is inlined at each call site that omits the argument — there is zero runtime overhead and no function signature change.
+
+```mt
+function configure(host: str, port: int = 8080, debug: bool = false) -> void:
+    pass
+
+configure("localhost")                     # port=8080, debug=false
+configure("localhost", port = 3000)        # debug=false
+configure(host = "remote", debug = true)   # port=8080
+```
+
+Defaults are not supported on `external function` or `foreign function` declarations.
+
 Rules:
 
 - Parameters must be typed.
@@ -566,7 +579,7 @@ Scrutinee types supported:
 
 - Enum: arm patterns must be members of that enum.
 - Variant: arm patterns must be arms of that variant; a payload arm may bind its fields with `as name` or destructure them inline with struct patterns.
-- Integer (`byte`, `short`, `int`, `long`, `ubyte`, `ushort`, `uint`, `ulong`, `ptr_int`, `ptr_uint`): arm patterns must be integer literals or char literals.
+- Integer (`byte`, `short`, `int`, `long`, `ubyte`, `ushort`, `uint`, `ulong`, `ptr_int`, `ptr_uint`): arm patterns must be integer literals, char literals, or range patterns (`a..b`).
 - `str`: arm patterns must be string literals (e.g., `"lex": ...`). Matches via full content comparison using the `equal` builtin.
 - Tuple: arm patterns must be tuple literal patterns whose elements may be integer literals, char literals, string literals, booleans, or `_` discard.
 
@@ -960,6 +973,7 @@ Rules:
 - `ivec2` `ivec3` `ivec4` — integer vectors with `.x` `.y` `.z` `.w` fields
 - `mat3` `mat4` — column-major matrices; `mat3` has columns `.col0`–`.col2` (each `vec3`), `mat4` has `.col0`–`.col3` (each `vec4`)
 - `quat` — quaternion with `.x` `.y` `.z` `.w` fields; memory-layout compatible with `vec4`
+- `simd[T, N]` — SIMD vector with `N` lanes of numeric primitive type `T`; total width must be 128 or 256 bits. Supports component-wise arithmetic (`+` `-` `*` `/`), bitwise (`&` `|` `^` `~`), shift (`<<` `>>`), and compound assignment. Lane access via compile-time constant index `[i]`. Lowers to GCC/Clang `__attribute__((__vector_size__))`.
 
 Primitive type names are reserved. They cannot be reused for value bindings, parameters, locals, import aliases, or type parameters.
 
@@ -995,6 +1009,7 @@ let q = quat(x = 0.0, y = 0.0, z = 0.0, w = 1.0)
 - `Option[T]`
 - `Result[T, E]`
 - `SoA[T, N]` — Structure-of-Arrays: transforms `T`'s fields into separate arrays of length `N`; access as `soa[i].field`
+- `simd[T, N]` — SIMD vector: fixed-width vector of `N` numeric lanes. Constructed with `simd[T, N](lane0, lane1, ...)`. Supports component-wise `+` `-` `*` `/`, bitwise `&` `|` `^` `~`, shift `<<` `>>`, unary `-` `~`, and compound assignment. Lane access via compile-time constant `[i]`. Total width must be 128 or 256 bits. Lowers to GCC/Clang vector extensions.
 - `dyn[InterfaceName]` — runtime interface value (fat pointer: data + vtable). Constructed via `adapt[Interface](value: ref[T])`. @see §3.5.
 - `atomic[T]` — atomic value for lock-free concurrent access. `T` must be a primitive integer or `bool`. Methods: `load() -> T`, `store(value: T)`, `add(value: T) -> T`, `sub(value: T) -> T`, `exchange(value: T) -> T`. All operations use sequential consistency. Lowers to C11 `_Atomic T` with `__atomic_*` builtins. `atomic[T]` is zero-initializable and sendable.
 - `(T, U)` — tuple type. Positional fields auto-named `_0`, `_1`. Named fields use `(x = T, y = U)`. Copy by value, returns supported.

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/core/ast.rb

@@ -117,8 +117,8 @@ module MilkTea
     ForeignFunctionDecl = Data.define(:name, :type_params, :params, :return_type, :variadic, :mapping, :visibility, :attributes, :line) do
       def initialize(name:, type_params:, params:, return_type:, variadic:, mapping:, visibility:, attributes: [], line: nil) = super
     end
-    Param = Data.define(:name, :type, :line, :column) do
-      def initialize(name:, type:, line: nil, column: nil) = super
+    Param = Data.define(:name, :type, :line, :column, :default_value) do
+      def initialize(name:, type:, line: nil, column: nil, default_value: nil) = super
     end
     ForeignParam = Data.define(:name, :type, :mode, :boundary_type)
     LocalDecl = Data.define(:kind, :name, :type, :value, :else_binding, :else_body, :line, :column, :recovered_else, :destructure_bindings, :destructure_type_name) do

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

@@ -95,6 +95,8 @@ module MilkTea
               emit_aggregate_literal(expression)
             when IR::ArrayLiteral
               emit_array_compound_literal(expression)
+            when IR::SimdLaneWith
+              emit_simd_lane_with(expression)
             when IR::VariantLiteral
               emit_variant_literal(expression)
             else
@@ -359,6 +361,15 @@ module MilkTea
             "(#{c_declaration(expression.type, '')}) #{emit_array_initializer(expression)}"
           end
 
+          def emit_simd_lane_with(expression)
+            simd_type = expression.type
+            elem_c = primitive_c_type(simd_type.element_type.name)
+            src = wrap_expression(expression.src)
+            idx = emit_expression(expression.index)
+            val = wrap_expression(expression.value)
+            "({ #{c_type(simd_type)} _mt_with = #{src}; ((#{elem_c}*)&_mt_with)[#{idx}] = #{val}; _mt_with; })"
+          end
+
           def emit_zero_initializer(type)
             return "{ 0 }" if type.is_a?(Types::StringView)
             return "{ 0 }" if array_type?(type)

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

@@ -270,6 +270,55 @@ module MilkTea
             end
           end
 
+          def collect_simd_types
+            simd_types = []
+            visited = {}
+
+            emitted_functions.each do |function|
+              collect_simd_type(function.return_type, simd_types, visited)
+              function.params.each do |param|
+                collect_simd_type(param.type, simd_types, visited)
+              end
+              collect_simd_from_statements(function.body, simd_types, visited)
+            end
+
+            @program.structs.each do |struct_decl|
+              struct_decl.fields.each do |field|
+                collect_simd_type(field.type, simd_types, visited)
+              end
+            end
+
+            simd_types.uniq
+          end
+
+          def collect_simd_from_statements(statements, simd_types, visited)
+            statements.each do |stmt|
+              case stmt
+              when IR::LocalDecl
+                collect_simd_type(stmt.type, simd_types, visited)
+              when IR::BlockStmt
+                collect_simd_from_statements(stmt.body, simd_types, visited)
+              when IR::IfStmt
+                collect_simd_from_statements(stmt.then_body || [], simd_types, visited)
+                collect_simd_from_statements(stmt.else_body || [], simd_types, visited)
+              when IR::WhileStmt
+                collect_simd_from_statements(stmt.body || [], simd_types, visited)
+              when IR::ForStmt
+                collect_simd_from_statements(stmt.body || [], simd_types, visited)
+              end
+            end
+          end
+
+          def collect_simd_type(type, simd_types, visited)
+            return unless type
+            return if visited[type]
+
+            if type.is_a?(Types::Simd)
+              simd_types << type
+              visited[type] = true
+            end
+          end
+
           def collect_generic_struct_decls
             collect_generic_struct_types.map do |type|
               fields = type.fields.map { |field_name, field_type| IR::Field.new(name: field_name, type: field_type) }

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

@@ -195,6 +195,13 @@ module MilkTea
             lines
           end
 
+          def emit_simd_type(type)
+            name = simd_type_name(type)
+            elem_c = primitive_c_type(type.element_type.name)
+            width = type.lane_count * Layout.primitive_layout(type.element_type).first
+            ["typedef #{elem_c} #{name} __attribute__((__vector_size__(#{width})));"]
+          end
+
           def struct_layout_attributes(struct_decl)
             attributes = []
             attributes << "packed" if struct_decl.packed

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

@@ -162,6 +162,9 @@ module MilkTea
             when Types::SoA
               base = soa_type_name(type)
               pointer ? "#{base}*" : base
+            when Types::Simd
+              base = simd_type_name(type)
+              pointer ? "#{base}*" : base
             when Types::Tuple
               base = tuple_type_name(type)
               pointer ? "#{base}*" : base
@@ -191,6 +194,11 @@ module MilkTea
             "mt_soa_#{element_name}_#{type.count}"
           end
 
+          def simd_type_name(type)
+            element_name = sanitize_identifier(type.element_type.to_s)
+            "mt_simd_#{element_name}x#{type.lane_count}"
+          end
+
           def tuple_type_name(type)
             sanitized = type.element_types.map { |et| sanitize_identifier(et.to_s) }.join("_")
             base = "mt_tuple_#{sanitized}"
@@ -268,6 +276,10 @@ module MilkTea
               raise CBackendError, "ref requires at least one type argument" unless [1, 2].include?(type.arguments.length)
 
               "#{c_type(type.arguments.length == 1 ? type.arguments.first : type.arguments[1])}*"
+            when "array"
+              raise CBackendError, "array requires exactly two type arguments" unless type.arguments.length == 2
+
+              c_type(type.arguments.first)
             when "str_buffer"
               raise CBackendError, "str_buffer requires exactly one type argument" unless str_buffer_type?(type)
 

data/lib/milk_tea/core/c_backend.rb

@@ -169,6 +169,14 @@ module MilkTea
         lines << ""
       end
 
+      collect_simd_types.each do |type|
+        next if @emitted_simd_type_names&.include?(simd_type_name(type))
+        @emitted_simd_type_names ||= Set.new
+        @emitted_simd_type_names.add(simd_type_name(type))
+        lines.concat(emit_simd_type(type))
+        lines << ""
+      end
+
       if uses_entrypoint_argv_helpers?
         lines.concat(emit_entrypoint_argv_helpers)
         lines << ""

data/lib/milk_tea/core/compatibility_helpers.rb

@@ -41,6 +41,10 @@ module MilkTea
       "compare_exchange" => :atomic_compare_exchange,
     }.freeze
 
+    SIMD_METHOD_KINDS = {
+      "with" => :simd_lane_with,
+    }.freeze
+
     def type_ref_from_specialization(expression)
       case expression.callee
       when AST::Identifier

data/lib/milk_tea/core/compile_time.rb

@@ -108,6 +108,22 @@ module MilkTea
                   end
                 end
               end
+              
+              types = if @checker.respond_to?(:types)
+                         @checker.types
+                       else
+                         @checker.instance_variable_get(:@ctx).types
+                       end
+              if (type = types[call_expr.callee.name]) && type.is_a?(Types::Struct)
+                fields = {}
+                call_expr.arguments.each do |argument|
+                  val = evaluate_expression(argument.value, scopes:)
+                  return nil unless val
+                  fields[argument.name] = val
+                end
+                next fields
+              end
+              
               @checker.send(:evaluate_compile_time_const_value, call_expr, scopes:)
             },
           )

data/lib/milk_tea/core/ir.rb

@@ -76,6 +76,7 @@ module MilkTea
     AggregateLiteral = Data.define(:type, :fields)
     AggregateField = Data.define(:name, :value)
     ArrayLiteral = Data.define(:type, :elements)
+    SimdLaneWith = Data.define(:src, :index, :value, :type)
     VariantDecl = Data.define(:name, :linkage_name, :arms, :source_module) do
       def initialize(name:, linkage_name:, arms:, source_module: nil) = super
     end

data/lib/milk_tea/core/keywords.rb

@@ -90,7 +90,7 @@ module MilkTea
   ].freeze
 
   BUILTIN_TYPE_NAMES = (BUILTIN_PRIMITIVE_NAMES + %w[
-    ptr const_ptr own ref span array str_buffer atomic Task Option Result SoA
+    ptr const_ptr own ref span array str_buffer atomic Task Option Result SoA simd
     struct_handle field_handle callable_handle attribute_handle member_handle type
     EventError Subscription
   ]).freeze

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

@@ -597,24 +597,56 @@ module MilkTea
               end
               lowered.concat(else_body)
             else
-              arm_loop_flow = switch_loop_flow(loop_flow, local_defers)
-              cases = statement.arms.map do |arm|
-                body = lower_block(
-                  arm.body,
-                  env: local_env,
-                  active_defers: active_defers + local_defers,
-                  return_type:,
-                  loop_flow: arm_loop_flow,
-                  allow_return:,
-                )
-                if wildcard_arm_pattern?(arm.pattern)
-                  IR::SwitchDefaultCase.new(body:)
-                else
-                  value = lower_expression(arm.pattern, env: local_env, expected_type: scrutinee_type)
-                  IR::SwitchCase.new(value:, body:)
+              has_range_arms = statement.arms.any? { |arm| arm.pattern.is_a?(AST::RangeExpr) }
+
+              if has_range_arms
+                arm_loop_flow = switch_loop_flow(loop_flow, local_defers)
+                bool_type = @ctx.types.fetch("bool")
+                non_wildcard = statement.arms.reject { |arm| wildcard_arm_pattern?(arm.pattern) }
+                wildcard = statement.arms.find { |arm| wildcard_arm_pattern?(arm.pattern) }
+                else_body = if wildcard
+                              lower_block(wildcard.body, env: local_env, active_defers: active_defers + local_defers, return_type:, loop_flow: arm_loop_flow, allow_return:)
+                            else
+                              []
+                            end
+                non_wildcard.reverse_each do |arm|
+                  arm_body = lower_block(
+                    arm.body,
+                    env: local_env,
+                    active_defers: active_defers + local_defers,
+                    return_type:,
+                    loop_flow: arm_loop_flow,
+                    allow_return:,
+                  )
+                  cond = if arm.pattern.is_a?(AST::RangeExpr)
+                           lower_range_match_condition(arm.pattern, expression, bool_type, env: local_env)
+                         else
+                           lit = lower_expression(arm.pattern, env: local_env, expected_type: scrutinee_type)
+                           IR::Binary.new(operator: "==", left: expression, right: lit, type: bool_type)
+                         end
+                  else_body = [IR::IfStmt.new(condition: cond, then_body: arm_body, else_body:)]
+                end
+                lowered.concat(else_body)
+              else
+                arm_loop_flow = switch_loop_flow(loop_flow, local_defers)
+                cases = statement.arms.map do |arm|
+                  body = lower_block(
+                    arm.body,
+                    env: local_env,
+                    active_defers: active_defers + local_defers,
+                    return_type:,
+                    loop_flow: arm_loop_flow,
+                    allow_return:,
+                  )
+                  if wildcard_arm_pattern?(arm.pattern)
+                    IR::SwitchDefaultCase.new(body:)
+                  else
+                    value = lower_expression(arm.pattern, env: local_env, expected_type: scrutinee_type)
+                    IR::SwitchCase.new(value:, body:)
+                  end
                 end
+                lowered << IR::SwitchStmt.new(expression:, cases:, exhaustive: true)
               end
-              lowered << IR::SwitchStmt.new(expression:, cases:, exhaustive: true)
             end
             lowered.concat(expression_cleanups.flat_map(&:itself))
             end

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

@@ -26,7 +26,9 @@ module MilkTea
             return lower_foreign_call_inline(expression, callee_binding, env:, type:)
           end
 
-          arguments = lower_call_arguments(expression.arguments, callee_type, env:)
+          lowered_arguments = expression.arguments
+          lowered_arguments = expand_function_defaults(lowered_arguments, callee_binding) if callee_binding
+          arguments = lower_call_arguments(lowered_arguments, callee_type, env:)
           IR::Call.new(callee: callee_name, arguments:, type:)
         when :callable_value
           callee_expression = lower_expression(expression.callee, env:, expected_type: callee_type)
@@ -136,6 +138,8 @@ module MilkTea
           end
         when :atomic_load, :atomic_store, :atomic_add, :atomic_sub, :atomic_exchange, :atomic_compare_exchange
           lower_atomic_method_call(kind, receiver, expression, env:, type:)
+        when :simd_lane_with
+          lower_simd_lane_with(kind, receiver, expression, env:, type:)
         when :associated_method
           arguments = lower_call_arguments(expression.arguments, callee_type, env:)
           IR::Call.new(callee: callee_name, arguments:, type:)
@@ -218,6 +222,12 @@ module MilkTea
             lower_contextual_expression(argument.value, env:, expected_type: element_type)
           end
           IR::ArrayLiteral.new(type:, elements:)
+        when :simd
+          element_type = simd_type?(type) ? type.element_type : array_element_type(type)
+          elements = expression.arguments.map do |argument|
+            lower_contextual_expression(argument.value, env:, expected_type: element_type)
+          end
+          IR::ArrayLiteral.new(type:, elements:)
         when :reinterpret
           argument = expression.arguments.fetch(0)
           source_type = infer_expression_type(argument.value, env:)
@@ -366,6 +376,49 @@ module MilkTea
         IR::AddressOf.new(expression: lowered_expression, type: pointer_type)
       end
 
+      def expand_function_defaults(arguments, binding)
+        return arguments unless binding.respond_to?(:ast) && binding.ast.respond_to?(:params)
+
+        ast_params = binding.ast.params
+        has_defaults = ast_params.any? { |p| p.respond_to?(:default_value) && p.default_value }
+        return arguments unless has_defaults || arguments.any?(&:name)
+
+        if arguments.any?(&:name)
+          by_position = Array.new(ast_params.length)
+          param_names = ast_params.map(&:name)
+
+          arguments.each do |arg|
+            if arg.name
+              param_idx = param_names.index(arg.name)
+              next unless param_idx
+
+              by_position[param_idx] = arg
+            else
+              first_empty = by_position.index(nil)
+              by_position[first_empty] = arg if first_empty
+            end
+          end
+
+          by_position.each_with_index do |slot, idx|
+            next if slot
+            next unless ast_params[idx].respond_to?(:default_value) && ast_params[idx].default_value
+
+            by_position[idx] = AST::Argument.new(name: nil, value: ast_params[idx].default_value)
+          end
+
+          by_position.compact
+        else
+          expanded = arguments.dup
+          while expanded.length < ast_params.length
+            ast_param = ast_params[expanded.length]
+            break unless ast_param.respond_to?(:default_value) && ast_param.default_value
+
+            expanded << AST::Argument.new(name: nil, value: ast_param.default_value)
+          end
+          expanded
+        end
+      end
+
       def lower_call_arguments(arguments, callee_type, env:)
         arguments.map.with_index do |argument, index|
           parameter = index < callee_type.params.length ? callee_type.params[index] : nil
@@ -1517,6 +1570,14 @@ module MilkTea
         end
       end
 
+      def simd_method_kind(receiver_type, name)
+        return unless simd_type?(receiver_type)
+
+        case name
+        when "with" then :simd_lane_with
+        end
+      end
+
       def lower_atomic_method_call(kind, receiver, expression, env:, type:)
         receiver_type = infer_expression_type(receiver, env:)
         elem_type = atomic_element_type(receiver_type)
@@ -1545,6 +1606,19 @@ module MilkTea
         end
       end
 
+      def lower_simd_lane_with(_kind, receiver, expression, env:, type:)
+        receiver_ir = lower_expression(receiver, env:)
+        index_ir = lower_expression(expression.arguments[0].value, env:, expected_type: @ctx.types.fetch("int"))
+        value_ir = lower_contextual_expression(expression.arguments[1].value, env:, expected_type: type.element_type)
+
+        IR::SimdLaneWith.new(
+          src: receiver_ir,
+          index: index_ir,
+          value: value_ir,
+          type:,
+        )
+      end
+
       def lower_event_subscribe_call(expression, env:, runtime:, event_pointer:, type:, once: false)
         stateful = expression.arguments.length == 2
         callee_key = if stateful

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

@@ -72,6 +72,13 @@ module MilkTea
             lower_const_value_literal(element_type, element)
           end
           IR::ArrayLiteral.new(type:, elements:)
+        when Hash
+          fields = const_value.map do |name, field_value|
+            field_type = type.field(name)
+            raise LoweringError, "constant struct field #{name} not found in #{type}" unless field_type
+            IR::AggregateField.new(name:, value: lower_const_value_literal(field_type, field_value))
+          end
+          IR::AggregateLiteral.new(type:, fields:)
         else
           IR::IntegerLiteral.new(value: 0, type:)
         end

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

@@ -1125,6 +1125,7 @@ module MilkTea
 
         switch_expression = lowered_expression
         string_if_chain = nil
+        range_if_chain = nil
         cases = if scrutinee_type.is_a?(Types::Variant)
                   kind_type = @ctx.types.fetch("int")
                   switch_expression = IR::Member.new(receiver: lowered_expression, member: "kind", type: kind_type)
@@ -1194,20 +1195,50 @@ module MilkTea
                   string_if_chain = else_body
                   nil
                 else
-                  expression.arms.map do |arm|
-                    arm_env = duplicate_env(env)
-                    value_setup, prepared_value = prepare_expression_for_inline_lowering(arm.value, env: arm_env, expected_type: result_type)
-                    body = value_setup + [IR::Assignment.new(target: result_ref, operator: "=", value: lower_contextual_expression(prepared_value, env: arm_env, expected_type: result_type))]
-                    if wildcard_arm_pattern?(arm.pattern)
-                      IR::SwitchDefaultCase.new(body: body)
-                    else
-                      IR::SwitchCase.new(value: lower_expression(arm.pattern, env: arm_env, expected_type: scrutinee_type), body: body)
+                  has_range_arms = expression.arms.any? { |arm| arm.pattern.is_a?(AST::RangeExpr) }
+
+                  if has_range_arms
+                    bool_type = @ctx.types.fetch("bool")
+                    non_wildcard = expression.arms.reject { |arm| wildcard_arm_pattern?(arm.pattern) }
+                    wildcard = expression.arms.find { |arm| wildcard_arm_pattern?(arm.pattern) }
+                    else_body = []
+                    if wildcard
+                      wildcard_env = duplicate_env(env)
+                      wildcard_value_setup, wildcard_prepared = prepare_expression_for_inline_lowering(wildcard.value, env: wildcard_env, expected_type: result_type)
+                      else_body = wildcard_value_setup + [IR::Assignment.new(target: result_ref, operator: "=", value: lower_contextual_expression(wildcard_prepared, env: wildcard_env, expected_type: result_type))]
+                    end
+                    non_wildcard.reverse_each do |arm|
+                      arm_env = duplicate_env(env)
+                      value_setup, prepared_value = prepare_expression_for_inline_lowering(arm.value, env: arm_env, expected_type: result_type)
+                      then_body = value_setup + [IR::Assignment.new(target: result_ref, operator: "=", value: lower_contextual_expression(prepared_value, env: arm_env, expected_type: result_type))]
+                      cond = if arm.pattern.is_a?(AST::RangeExpr)
+                               lower_range_match_condition(arm.pattern, switch_expression, bool_type, env: arm_env)
+                             else
+                               lit = lower_expression(arm.pattern, env: arm_env, expected_type: scrutinee_type)
+                               IR::Binary.new(operator: "==", left: switch_expression, right: lit, type: bool_type)
+                             end
+                      else_body = [IR::IfStmt.new(condition: cond, then_body:, else_body:)]
+                    end
+                    range_if_chain = else_body
+                    nil
+                  else
+                    expression.arms.map do |arm|
+                      arm_env = duplicate_env(env)
+                      value_setup, prepared_value = prepare_expression_for_inline_lowering(arm.value, env: arm_env, expected_type: result_type)
+                      body = value_setup + [IR::Assignment.new(target: result_ref, operator: "=", value: lower_contextual_expression(prepared_value, env: arm_env, expected_type: result_type))]
+                      if wildcard_arm_pattern?(arm.pattern)
+                        IR::SwitchDefaultCase.new(body: body)
+                      else
+                        IR::SwitchCase.new(value: lower_expression(arm.pattern, env: arm_env, expected_type: scrutinee_type), body: body)
+                      end
                     end
                   end
                 end
 
         if string_if_chain
           [setup + string_if_chain, AST::Identifier.new(name: result_name)]
+        elsif range_if_chain
+          [setup + range_if_chain, AST::Identifier.new(name: result_name)]
         else
           [setup + [IR::SwitchStmt.new(expression: switch_expression, cases: cases, exhaustive: true)], AST::Identifier.new(name: result_name)]
         end