mt-lang 0.2.22 → 0.3.0

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

@@ -291,6 +291,8 @@ module MilkTea
 
           return Types::Registry.soa(arguments[0], count: arguments[1].value) if name == "SoA"
 
+          return Types::Registry.simd(arguments[0], lane_count: arguments[1].value) if name == "simd"
+
           arguments = [type_ref.lifetime] + arguments if name == "ref" && type_ref.lifetime
           return Types::Registry.generic_instance(name, arguments)
         end
@@ -684,6 +686,7 @@ module MilkTea
         return true if matrix_type?(type)
         return true if quaternion_type?(type)
         return true if soa_type?(type)
+        return true if simd_type?(type)
         return true if atomic_type?(type)
 
         raise_sema_error("#{operation} does not support type #{type}")
@@ -717,6 +720,10 @@ module MilkTea
         type.is_a?(Types::SoA)
       end
 
+      def simd_type?(type)
+        type.is_a?(Types::Simd)
+      end
+
       def array_type?(type)
         type.is_a?(Types::GenericInstance) && type.name == "array" && type.arguments.length == 2 &&
           !type.arguments.first.is_a?(Types::LiteralTypeArg) && type.arguments[1].is_a?(Types::LiteralTypeArg)
@@ -929,6 +936,10 @@ module MilkTea
           return receiver_type.element_type
         end
 
+        if simd_type?(receiver_type)
+          return receiver_type.element_type
+        end
+
         if pointer_type?(receiver_type)
           require_unsafe!("pointer indexing requires unsafe") unless own_type?(receiver_type)
 

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

@@ -511,15 +511,15 @@ module MilkTea
             )
           end
         when "%="
-          unless common_integer_type(target_type, value_type) == target_type
+          unless common_integer_type(target_type, value_type) == target_type || simd_mod_result(target_type, value_type)
             raise_sema_error("operator #{statement.operator} requires compatible integer types, got #{target_type} and #{value_type}")
           end
         when "&=", "|=", "^="
-          unless target_type == value_type && bitwise_type?(target_type)
+          unless (target_type == value_type && bitwise_type?(target_type)) || (simd_type?(target_type) && simd_type?(value_type) && target_type == value_type)
             raise_sema_error("operator #{statement.operator} requires matching integer or flags types, got #{target_type} and #{value_type}")
           end
         when "<<=", ">>="
-          unless target_type.is_a?(Types::Primitive) && target_type.integer? && value_type.is_a?(Types::Primitive) && value_type.integer?
+          unless (target_type.is_a?(Types::Primitive) && target_type.integer? && value_type.is_a?(Types::Primitive) && value_type.integer?) || simd_shift_result(target_type, value_type)
             raise_sema_error("operator #{statement.operator} requires integer operands, got #{target_type} and #{value_type}")
           end
         else
@@ -645,8 +645,25 @@ module MilkTea
             check_block(arm.body, scopes:, return_type:, allow_return:)
             next
           end
+          if arm.pattern.is_a?(AST::RangeExpr)
+            start_val = arm.pattern.start_expr
+            end_val   = arm.pattern.end_expr
+            unless (start_val.is_a?(AST::IntegerLiteral) || start_val.is_a?(AST::CharLiteral)) &&
+                   (end_val.is_a?(AST::IntegerLiteral) || end_val.is_a?(AST::CharLiteral))
+              raise_sema_error("range match arm bounds must be integer or char literals, got #{start_val.class.name}..#{end_val.class.name}")
+            end
+
+            raise_sema_error("range match arm start #{start_val.value} must be <= end #{end_val.value}") if start_val.value > end_val.value
+
+            range_key = [start_val.value, end_val.value]
+            raise_sema_error("duplicate match arm range #{range_key[0]}..#{range_key[1]}") if covered_values.key?(range_key)
+
+            covered_values[range_key] = true
+            check_block(arm.body, scopes:, return_type:, allow_return:)
+            next
+          end
           unless arm.pattern.is_a?(AST::IntegerLiteral) || arm.pattern.is_a?(AST::CharLiteral)
-            raise_sema_error("match arm for integer scrutinee must be an integer literal, char literal, or _, got #{arm.pattern.class.name}")
+            raise_sema_error("match arm for integer scrutinee must be an integer literal, char literal, range, or _, got #{arm.pattern.class.name}")
           end
           value = arm.pattern.value
           raise_sema_error("duplicate match arm value #{value}") if covered_values.key?(value)

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

@@ -324,6 +324,29 @@ module MilkTea
       def evaluate_compile_time_call(expression, scopes: nil)
         case expression.callee
         when AST::Identifier
+          if (struct_type = @ctx.types[expression.callee.name]) && struct_type.is_a?(Types::Struct)
+            fields = {}
+            expression.arguments.each do |argument|
+              val = CompileTime.evaluate(argument.value, resolve_identifier: lambda { |id|
+                if scopes
+                  binding = lookup_value(id.name, scopes)
+                  return binding.const_value unless binding&.const_value.nil?
+                end
+                resolve_current_module_const_value(id.name)
+              }, resolve_member_access: lambda { |ma|
+                if (receiver_type = resolve_type_expression(ma.receiver))
+                  next resolve_enum_member_const_value(receiver_type, ma.member)
+                end
+                nil
+              }, resolve_call: lambda { |inner_call|
+                evaluate_compile_time_call(inner_call, scopes:)
+              })
+              return nil unless val
+              fields[argument.name] = val
+            end
+            return fields
+          end
+
           case expression.callee.name
           when "field_of"
             evaluate_field_of_call(expression.arguments, scopes: scopes || [])

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

@@ -218,12 +218,49 @@ module MilkTea
         return vector_op_result(operator, left_type, right_type) if vector_type?(left_type) || vector_type?(right_type)
         return matrix_op_result(operator, left_type, right_type) if matrix_type?(left_type) || matrix_type?(right_type)
         return quaternion_op_result(operator, left_type, right_type) if quaternion_type?(left_type) || quaternion_type?(right_type)
+        return simd_op_result(operator, left_type, right_type) if simd_type?(left_type) || simd_type?(right_type)
 
         nil
       end
 
     private
 
+      def simd_op_result(operator, left_type, right_type)
+        if simd_type?(left_type) && simd_type?(right_type) && left_type.element_type == right_type.element_type && left_type.lane_count == right_type.lane_count
+          return left_type if operator == "+" || operator == "-" || operator == "*" || operator == "/"
+        end
+
+        if simd_type?(left_type) && right_type.numeric? && right_type == left_type.element_type
+          return left_type if operator == "*" || operator == "/"
+        end
+
+        if left_type.numeric? && simd_type?(right_type) && left_type == right_type.element_type
+          return right_type if operator == "*"
+        end
+
+        nil
+      end
+
+      def simd_bitwise_result(left_type, right_type)
+        return nil unless simd_type?(left_type) && simd_type?(right_type) && left_type == right_type
+
+        left_type
+      end
+
+      def simd_mod_result(left_type, right_type)
+        return nil unless simd_type?(left_type) && left_type.element_type.integer?
+        return nil unless right_type == left_type.element_type || (simd_type?(right_type) && right_type == left_type)
+
+        left_type
+      end
+
+      def simd_shift_result(left_type, right_type)
+        return nil unless simd_type?(left_type) && left_type.element_type.integer?
+        return nil unless right_type.is_a?(Types::Primitive) && right_type.integer?
+
+        left_type
+      end
+
       def vector_op_result(operator, left_type, right_type)
         if vector_type?(left_type) && vector_type?(right_type) && left_type.element_type == right_type.element_type
           return left_type if operator == "+" || operator == "-"

data/lib/milk_tea/core/types/layout.rb

@@ -70,6 +70,13 @@ module MilkTea
         end
       when Types::GenericInstance
         generic_layout(type, stack)
+      when Types::Simd
+        element_layout = size_and_alignment(type.element_type, stack)
+        return unless element_layout
+
+        total = element_layout.first * type.lane_count
+        alignment = total > 16 ? 32 : 16
+        [total, alignment]
       else
         nil
       end

data/lib/milk_tea/core/types/predicates.rb

@@ -4,18 +4,38 @@ module MilkTea
   module TypePredicates
     def method_dispatch_receiver_type(receiver_type)
       return receiver_type.definition if receiver_type.is_a?(Types::StructInstance) || receiver_type.is_a?(Types::VariantInstance)
+
       if receiver_type.is_a?(Types::Nullable)
         dispatch_base_type = method_dispatch_receiver_type(receiver_type.base)
         return receiver_type if dispatch_base_type == receiver_type.base
 
         return Types::Registry.nullable(dispatch_base_type)
       end
+
+      case receiver_type
+      when Types::Span
+        normalized = Types::Registry.span(Types::TypeVar.new("__receiver_arg0"))
+        return normalized == receiver_type ? receiver_type : normalized
+      when Types::SoA
+        normalized = Types::Registry.soa(Types::TypeVar.new("__receiver_arg0"), count: 0)
+        return normalized == receiver_type ? receiver_type : normalized
+      when Types::Simd
+        normalized = Types::Registry.simd(Types::TypeVar.new("__receiver_arg0"), lane_count: 0)
+        return normalized == receiver_type ? receiver_type : normalized
+      when Types::Task
+        normalized = Types::Registry.task(Types::TypeVar.new("__receiver_arg0"))
+        return normalized == receiver_type ? receiver_type : normalized
+      when Types::Dyn
+        normalized = Types::Registry.dyn(Types::TypeVar.new("__receiver_arg0"))
+        return normalized == receiver_type ? receiver_type : normalized
+      end
+
       return receiver_type unless receiver_type.is_a?(Types::GenericInstance)
 
       dispatch_receiver_type = Types::Registry.generic_instance(
         receiver_type.name,
-        receiver_type.arguments.each_with_index.map do |argument, index|
-          argument.is_a?(Types::LiteralTypeArg) ? argument : Types::TypeVar.new("__receiver_arg#{index}")
+        receiver_type.arguments.each_with_index.map do |_argument, index|
+          Types::TypeVar.new("__receiver_arg#{index}")
         end,
       )
       dispatch_receiver_type == receiver_type ? receiver_type : dispatch_receiver_type
@@ -458,9 +478,11 @@ module MilkTea
       actual_count == function_type.params.length
     end
 
-    def arity_error_message(function_type, name, actual_count)
+    def arity_error_message(function_type, name, actual_count, required_count: nil)
       if function_type.is_a?(Types::Function) && function_type.variadic
         "function #{name} expects at least #{function_type.params.length} arguments, got #{actual_count}"
+      elsif required_count && required_count < function_type.params.length
+        "function #{name} expects #{required_count}..#{function_type.params.length} arguments, got #{actual_count}"
       else
         "function #{name} expects #{function_type.params.length} arguments, got #{actual_count}"
       end
@@ -564,6 +586,17 @@ module MilkTea
         error.call("SoA element type must be a struct with fields") unless arguments.first.respond_to?(:fields) && arguments.first.fields.any?
         error.call("SoA length must be an integer literal, named const, or type parameter") unless generic_integer_type_argument?(arguments[1])
         error.call("SoA length must be positive") if integer_type_argument?(arguments[1]) && !arguments[1].value.positive?
+      when "simd"
+        error.call("simd requires exactly two type arguments") unless arguments.length == 2
+        error.call("simd element type must be a type") if arguments.first.is_a?(Types::LiteralTypeArg)
+        error.call("simd element type must be a numeric primitive") unless arguments.first.is_a?(Types::Primitive) && arguments.first.numeric?
+        error.call("simd lane count must be an integer literal, named const, or type parameter") unless generic_integer_type_argument?(arguments[1])
+        error.call("simd lane count must be positive") if integer_type_argument?(arguments[1]) && !arguments[1].value.positive?
+        if integer_type_argument?(arguments[1])
+          width_bytes = arguments.first.name == "double" || arguments.first.name == "long" || arguments.first.name == "ulong" ? arguments[1].value * 8 : arguments.first.name == "int" || arguments.first.name == "uint" || arguments.first.name == "float" ? arguments[1].value * 4 : arguments.first.name == "short" || arguments.first.name == "ushort" ? arguments[1].value * 2 : arguments[1].value
+          valid = [16, 32].include?(width_bytes)
+          error.call("simd width must be 128 or 256 bits, got #{width_bytes * 8}") unless valid
+        end
       when "str_buffer"
         error.call("str_buffer requires exactly one type argument") unless arguments.length == 1
         error.call("str_buffer capacity must be an integer literal, named const, or type parameter") unless generic_integer_type_argument?(arguments.first)
@@ -598,6 +631,14 @@ module MilkTea
       type.arguments.length == 2 && type.arguments[1].is_a?(Types::LiteralTypeArg) && type.arguments[1].value.is_a?(Integer)
     end
 
+    def soa_type?(type)
+      type.is_a?(Types::SoA)
+    end
+
+    def simd_type?(type)
+      type.is_a?(Types::Simd)
+    end
+
     def array_length(type)
       type.arguments[1].value
     end

data/lib/milk_tea/core/types/registry.rb

@@ -71,6 +71,10 @@ module MilkTea
         _intern([:soa, element_type, count]) { SoA.new(element_type, count: count) }
       end
 
+      def simd(element_type, lane_count:)
+        _intern([:simd, element_type, lane_count]) { Simd.new(element_type, lane_count: lane_count) }
+      end
+
       def lifetime_ref(name)
         LifetimeRef.new(name)
       end

data/lib/milk_tea/core/types/types.rb

@@ -1560,6 +1560,48 @@ module MilkTea
       end
     end
 
+    class Simd < Base
+      attr_reader :name, :element_type, :lane_count, :module_name
+
+      def initialize(element_type, lane_count:)
+        @element_type = element_type
+        @lane_count = lane_count
+        @name = "simd[#{element_type}, #{lane_count}]"
+        @module_name = nil
+        @fields = {}.freeze
+        @hash = [self.class, element_type, lane_count].hash
+        freeze
+      end
+
+      def eql?(other)
+        other.is_a?(Simd) && other.element_type == element_type && other.lane_count == lane_count
+      end
+
+      alias == eql?
+
+      attr_reader :hash
+
+      def fields
+        @fields
+      end
+
+      def field(name)
+        @fields[name]
+      end
+
+      def numeric?
+        true
+      end
+
+      def to_s
+        @name
+      end
+
+      def children
+        [element_type]
+      end
+    end
+
     class Tuple < Base
       attr_reader :element_types, :field_names
 

data/lib/milk_tea/core/types/visitor.rb

@@ -38,6 +38,7 @@ module MilkTea
       when Types::Tuple then visit_tuple(type)
       when Types::Dyn then visit_dyn(type)
       when Types::SoA then visit_soa(type)
+      when Types::Simd then visit_simd(type)
       when Types::Event then visit_event(type)
       when Types::LifetimeRef then visit_lifetime_ref(type)
       else visit_default(type)
@@ -66,6 +67,7 @@ module MilkTea
     def visit_tuple(type); visit_children(type); end
     def visit_dyn(type); visit_children(type); end
     def visit_soa(type); visit_children(type); end
+    def visit_simd(type); visit_children(type); end
     def visit_event(type); visit_children(type); end
 
     def visit_type_var(type); end

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

@@ -15,7 +15,7 @@ module MilkTea
         ].freeze
 
         TYPE_CONSTRUCTOR_KEYWORDS = %w[
-          ptr ref span array dyn Option Result Task SoA str_buffer const_ptr
+          ptr ref span array dyn Option Result Task SoA str_buffer const_ptr simd
         ].freeze
 
         private

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

@@ -263,6 +263,7 @@ module MilkTea
           'Option' => 'Built-in optional type: `Option[T]`. Arms: `some(value: T)` and `none`. Use `let ... else:` or `?` for safe unwrapping.',
           'Result' => 'Built-in result type: `Result[T, E]`. Arms: `success(value: T)` and `failure(error: E)`. Use `let ... else:` or `?` for error propagation.',
           'SoA' => 'Struct-of-Arrays: `SoA[T, N]`. Each struct field becomes a separate array of length `N`. Access `soa[i].field` reads from column `field` at row `i`.',
+          'simd' => 'SIMD vector type: `simd[T, N]`. Fixed-width vector of `N` lanes of numeric primitive type `T`. Supports component-wise arithmetic, lane access via `[i]`, and explicit aligned/unaligned load/store. Lowers to GCC/Clang vector extensions for portable, readable C output.',
           'struct_handle' => 'Compile-time handle for a struct type. Obtained via reflection builtins like `fields_of`.',
           'field_handle' => 'Compile-time handle for a struct field. Exposes `.name` and `.type`. Obtained via `field_of` and `fields_of`.',
           'callable_handle' => 'Compile-time handle for a callable declaration. Obtained via `callable_of`. Used with `has_attribute`, `attribute_of`.',
@@ -1561,7 +1562,7 @@ module MilkTea
       end
 
       def builtin_type_constructor_hover_info(name, tokens, token_index)
-        return nil unless %w[array span Option Result SoA str_buffer ref ptr const_ptr own Task atomic].include?(name)
+        return nil unless %w[array span Option Result SoA str_buffer ref ptr const_ptr own Task atomic simd].include?(name)
 
         lbracket_index = next_non_trivia_token_index(tokens, token_index + 1)
         return nil unless lbracket_index && tokens[lbracket_index].type == :lbracket
@@ -1580,6 +1581,8 @@ module MilkTea
                     '`span[T](data = ..., len = ...)` constructs a span view over contiguous `T` storage.'
                    when 'SoA'
                     '`SoA[T, N](...)` constructs a Struct-of-Arrays value with `N` elements of type `T`. Fields are stored in separate contiguous arrays.'
+                   when 'simd'
+                    '`simd[T, N](...)` constructs a SIMD vector value with `N` lanes of type `T`. Lanes are stored in a single vector register.'
                    when 'Option'
                     '`Option[T]` is a built-in optional type with arms `some(value: T)` and `none`.'
                    when 'Result'
@@ -1594,6 +1597,8 @@ module MilkTea
                          "builtin #{specialization}(data = ..., len = ...) -> #{specialization}"
                        when 'SoA'
                          "builtin #{specialization}(...) -> #{specialization}"
+                       when 'simd'
+                         "builtin #{specialization}(...) -> #{specialization}"
                        when 'Option'
                          "builtin #{specialization}(some: value = ...) / #{specialization}(none:)"
                        when 'Result'
@@ -1610,6 +1615,8 @@ module MilkTea
                  '`span[T]` is the built-in non-owning contiguous view type.'
                when 'SoA'
                  '`SoA[T, N]` is the built-in Struct-of-Arrays type. Each struct field is stored in a separate contiguous array of `N` elements, improving SIMD/cache behavior for parallel field access.'
+               when 'simd'
+                 '`simd[T, N]` is the built-in SIMD vector type. Fixed-width vector of `N` numeric lanes. Supports component-wise arithmetic, lane access via `[i]`, and explicit aligned/unaligned load/store.'
                when 'Option'
                  '`Option[T]` is the built-in optional value type with `some(value = ...)` and `none` arms.'
                when 'Result'

data/std/raylib.mt

@@ -452,9 +452,9 @@ public foreign function image_draw_rectangle(inout dst: Image, pos_x: int, pos_y
 public foreign function image_draw_rectangle_v(inout dst: Image, position: Vector2, size: Vector2, color: Color) -> void = c.ImageDrawRectangleV
 public foreign function image_draw_rectangle_rec(inout dst: Image, rec: Rectangle, color: Color) -> void = c.ImageDrawRectangleRec
 public foreign function image_draw_rectangle_lines(inout dst: Image, rec: Rectangle, thick: int, color: Color) -> void = c.ImageDrawRectangleLines
-public foreign function image_draw_triangle(inout dst: Image, v_1: Vector2, v_2: Vector2, v_3: Vector2, color: Color) -> void = c.ImageDrawTriangle
-public foreign function image_draw_triangle_ex(inout dst: Image, v_1: Vector2, v_2: Vector2, v_3: Vector2, c_1: Color, c_2: Color, c_3: Color) -> void = c.ImageDrawTriangleEx
-public foreign function image_draw_triangle_lines(inout dst: Image, v_1: Vector2, v_2: Vector2, v_3: Vector2, color: Color) -> void = c.ImageDrawTriangleLines
+public foreign function image_draw_triangle(inout dst: Image, v1: Vector2, v2: Vector2, v3: Vector2, color: Color) -> void = c.ImageDrawTriangle
+public foreign function image_draw_triangle_ex(inout dst: Image, v1: Vector2, v2: Vector2, v3: Vector2, c1: Color, c2: Color, c3: Color) -> void = c.ImageDrawTriangleEx
+public foreign function image_draw_triangle_lines(inout dst: Image, v1: Vector2, v2: Vector2, v3: Vector2, color: Color) -> void = c.ImageDrawTriangleLines
 public foreign function image_draw_triangle_fan(inout dst: Image, points: const_ptr[Vector2], point_count: int, color: Color) -> void = c.ImageDrawTriangleFan
 public foreign function image_draw_triangle_strip(inout dst: Image, points: const_ptr[Vector2], point_count: int, color: Color) -> void = c.ImageDrawTriangleStrip
 public foreign function image_draw(inout dst: Image, src: Image, src_rec: Rectangle, dst_rec: Rectangle, tint: Color) -> void = c.ImageDraw
@@ -926,23 +926,23 @@ extending Image:
         image_draw_rectangle_lines(this, rec, thick, color)
 
 
-    public editable function draw_triangle(v_1: Vector2, v_2: Vector2, v_3: Vector2, color: Color) -> void:
-        image_draw_triangle(this, v_1, v_2, v_3, color)
+    public editable function draw_triangle(v1: Vector2, v2: Vector2, v3: Vector2, color: Color) -> void:
+        image_draw_triangle(this, v1, v2, v3, color)
 
 
     public editable function draw_triangle_ex(
-        v_1: Vector2,
-        v_2: Vector2,
-        v_3: Vector2,
-        c_1: Color,
-        c_2: Color,
-        c_3: Color
+        v1: Vector2,
+        v2: Vector2,
+        v3: Vector2,
+        c1: Color,
+        c2: Color,
+        c3: Color
     ) -> void:
-        image_draw_triangle_ex(this, v_1, v_2, v_3, c_1, c_2, c_3)
+        image_draw_triangle_ex(this, v1, v2, v3, c1, c2, c3)
 
 
-    public editable function draw_triangle_lines(v_1: Vector2, v_2: Vector2, v_3: Vector2, color: Color) -> void:
-        image_draw_triangle_lines(this, v_1, v_2, v_3, color)
+    public editable function draw_triangle_lines(v1: Vector2, v2: Vector2, v3: Vector2, color: Color) -> void:
+        image_draw_triangle_lines(this, v1, v2, v3, color)
 
 
     public editable function draw_triangle_fan(points: const_ptr[Vector2], point_count: int, color: Color) -> void:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.2.22
+  version: 0.3.0
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -586,7 +586,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.2.22 installed!
+  Milk Tea 0.3.0 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH