mt-lang 0.2.22 → 0.3.0

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

@@ -86,7 +86,7 @@ module MilkTea
           end
 
           begin
-            return resolve_type_ref_for_analysis(type_name, analysis)
+            return method_dispatch_receiver_type(resolve_type_ref_for_analysis(type_name, analysis))
           rescue LoweringError => error
             receiver_type_param_names = methods_receiver_type_argument_names!(type_name)
             raise error if receiver_type_param_names.empty?

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

@@ -99,6 +99,9 @@ module MilkTea
       end
 
       def lower_array_to_span_expression(expression, target_type)
+        array_type = expression.type
+        array_type = referenced_type(array_type) if ref_type?(array_type)
+
         IR::AggregateLiteral.new(
           type: target_type,
           fields: [
@@ -115,7 +118,7 @@ module MilkTea
             ),
             IR::AggregateField.new(
               name: "len",
-              value: IR::IntegerLiteral.new(value: array_length(expression.type), type: @ctx.types.fetch("ptr_uint")),
+              value: IR::IntegerLiteral.new(value: array_length(array_type), type: @ctx.types.fetch("ptr_uint")),
             ),
           ],
         )
@@ -549,6 +552,8 @@ module MilkTea
                     when :atomic_compare_exchange then @ctx.types.fetch("bool")
                     end
               return [precomputed, nil, callee.receiver, Types::Registry.function(nil, params: [], return_type: ret)]
+            when :simd_lane_with
+              return [precomputed, nil, callee.receiver, Types::Registry.function(nil, params: [], return_type: resolved_receiver_type)]
             end
           end
 
@@ -571,6 +576,13 @@ module MilkTea
             return [atomic_method, nil, callee.receiver, Types::Registry.function(nil, params: [], return_type: ret)]
           end
 
+          if (simd_method = simd_method_kind(resolved_receiver_type, callee.member))
+            ret = case simd_method
+                  when :simd_lane_with then resolved_receiver_type
+                  end
+            return [simd_method, nil, callee.receiver, Types::Registry.function(nil, params: [], return_type: ret)]
+          end
+
           field_receiver_type = infer_field_receiver_type(callee.receiver, env:)
           if array_type?(field_receiver_type) && callee.member == "as_span"
             return [:array_as_span, nil, callee.receiver, Types::Registry.span(array_element_type(field_receiver_type))]
@@ -592,6 +604,11 @@ module MilkTea
             return [:array, nil, nil, array_type]
           end
 
+          if callee.callee.is_a?(AST::Identifier) && callee.callee.name == "simd"
+            simd_type = resolve_type_ref(AST::TypeRef.new(name: AST::QualifiedName.new(parts: ["simd"]), arguments: callee.arguments, nullable: false))
+            return [:simd, nil, nil, simd_type]
+          end
+
           if callee.callee.is_a?(AST::Identifier) && callee.callee.name == "span"
             span_type = resolve_type_ref(AST::TypeRef.new(name: AST::QualifiedName.new(parts: ["span"]), arguments: callee.arguments, nullable: false))
             return [:struct_literal, nil, nil, span_type]
@@ -663,7 +680,7 @@ module MilkTea
 
           if (type_ref = type_ref_from_specialization(callee))
             specialized_type = resolve_type_ref(type_ref)
-            return [:struct_literal, nil, nil, specialized_type] if specialized_type.is_a?(Types::Struct) || task_type?(specialized_type) || specialized_type.is_a?(Types::Vector) || specialized_type.is_a?(Types::Matrix) || specialized_type.is_a?(Types::Quaternion)
+            return [:struct_literal, nil, nil, specialized_type] if specialized_type.is_a?(Types::Struct) || task_type?(specialized_type) || specialized_type.is_a?(Types::Vector) || specialized_type.is_a?(Types::Matrix) || specialized_type.is_a?(Types::Quaternion) || specialized_type.is_a?(Types::Simd)
           end
 
           raise LoweringError, "unsupported specialization callee"
@@ -838,7 +855,7 @@ module MilkTea
             :reinterpret, :zero, :hash, :equal, :order,
             :dyn_method
             callee_type.return_type
-          when :struct_literal, :struct_with, :array, :variant_arm_ctor, :adapt
+          when :struct_literal, :struct_with, :array, :simd, :variant_arm_ctor, :adapt
             callee_type
           when :ref_of
             argument_type = infer_expression_type(expression.arguments.fetch(0).value, env:)
@@ -867,7 +884,8 @@ module MilkTea
                           receiver_type.element_type
                         end
             Types::Registry.nullable(Types::Registry.generic_instance("ptr", [elem_type]))
-          when :atomic_load, :atomic_add, :atomic_sub, :atomic_exchange, :atomic_store, :atomic_compare_exchange
+          when :atomic_load, :atomic_add, :atomic_sub, :atomic_exchange, :atomic_store, :atomic_compare_exchange,
+            :simd_lane_with
             callee_type.return_type
           else
             raise LoweringError, "unsupported call kind #{kind}"
@@ -1794,12 +1812,16 @@ module MilkTea
           @lowerer = lowerer
         end
 
+        def types
+          @lowerer.instance_variable_get(:@ctx).types
+        end
+
         def evaluate_compile_time_const_value(expression, scopes: nil)
           @lowerer.send(:compile_time_const_value, expression, env: @lowerer.send(:empty_env))
         end
 
         def top_level_function(name)
-          @lowerer.instance_variable_get(:@ctx.functions)&.[](name)
+          @lowerer.instance_variable_get(:@ctx).functions&.[](name)
         end
 
         def raise_sema_error(message)
@@ -2185,6 +2207,46 @@ module MilkTea
               raise LoweringError, "cannot use method #{binding.name} with receiver #{receiver_type}"
             end
           end
+        when Types::Span
+          return {} unless receiver_type.is_a?(Types::Span)
+
+          substitutions = {}
+          if declared_receiver_type.element_type.is_a?(Types::TypeVar)
+            substitutions[declared_receiver_type.element_type.name] = receiver_type.element_type
+          elsif declared_receiver_type.element_type != receiver_type.element_type
+            raise LoweringError, "cannot use method #{binding.name} with receiver #{receiver_type}"
+          end
+          substitutions
+        when Types::Task
+          return {} unless receiver_type.is_a?(Types::Task)
+
+          substitutions = {}
+          if declared_receiver_type.result_type.is_a?(Types::TypeVar)
+            substitutions[declared_receiver_type.result_type.name] = receiver_type.result_type
+          elsif declared_receiver_type.result_type != receiver_type.result_type
+            raise LoweringError, "cannot use method #{binding.name} with receiver #{receiver_type}"
+          end
+          substitutions
+        when Types::SoA
+          return {} unless receiver_type.is_a?(Types::SoA)
+
+          substitutions = {}
+          if declared_receiver_type.element_type.is_a?(Types::TypeVar)
+            substitutions[declared_receiver_type.element_type.name] = receiver_type.element_type
+          elsif declared_receiver_type.element_type != receiver_type.element_type
+            raise LoweringError, "cannot use method #{binding.name} with receiver #{receiver_type}"
+          end
+          substitutions
+        when Types::Simd
+          return {} unless receiver_type.is_a?(Types::Simd)
+
+          substitutions = {}
+          if declared_receiver_type.element_type.is_a?(Types::TypeVar)
+            substitutions[declared_receiver_type.element_type.name] = receiver_type.element_type
+          elsif declared_receiver_type.element_type != receiver_type.element_type
+            raise LoweringError, "cannot use method #{binding.name} with receiver #{receiver_type}"
+          end
+          substitutions
         else
           {}
         end
@@ -2393,6 +2455,9 @@ module MilkTea
                  elsif name == "SoA"
                    validate_generic_type!(name, args)
                    Types::Registry.soa(args.fetch(0), count: args.fetch(1).value)
+                 elsif name == "simd"
+                   validate_generic_type!(name, args)
+                   Types::Registry.simd(args.fetch(0), lane_count: args.fetch(1).value)
                  else
                    validate_generic_type!(name, args)
                    args = [type_ref.lifetime] + args if name == "ref" && type_ref.lifetime

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

@@ -9,6 +9,14 @@ module MilkTea
         range_expr?(expression)
       end
 
+      def lower_range_match_condition(range_pattern, scrutinee_ir, bool_type, env:)
+        start_ir = lower_expression(range_pattern.start_expr, env:, expected_type: nil)
+        end_ir   = lower_expression(range_pattern.end_expr, env:, expected_type: nil)
+        ge = IR::Binary.new(operator: ">=", left: scrutinee_ir, right: start_ir, type: bool_type)
+        le = IR::Binary.new(operator: "<=", left: scrutinee_ir, right: end_ir, type: bool_type)
+        IR::Binary.new(operator: "and", left: ge, right: le, type: bool_type)
+      end
+
       def range_start_of(iterable)
         iterable.start_expr
       end
@@ -80,6 +88,10 @@ module MilkTea
           type.arguments[1].is_a?(Types::LiteralTypeArg)
       end
 
+      def simd_type?(type)
+        type.is_a?(Types::Simd)
+      end
+
       def array_element_type(type)
         return unless array_type?(type)
 
@@ -321,6 +333,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)
           return pointee_type(receiver_type)
         end
@@ -417,6 +433,16 @@ module MilkTea
           if type == @ctx.types.fetch("str") || type == @ctx.types.fetch("cstr")
             return IR::StringLiteral.new(value:, type:, cstring: type == @ctx.types.fetch("cstr"))
           end
+        when Hash
+          return nil unless type.is_a?(Types::Struct)
+          fields = value.map do |name, field_value|
+            field_type = type.field(name)
+            return nil unless field_type
+            lowered = lower_compile_time_literal(field_value, field_type)
+            return nil unless lowered
+            IR::AggregateField.new(name:, value: lowered)
+          end
+          return IR::AggregateLiteral.new(type:, fields:)
         end
 
         nil

data/lib/milk_tea/core/module_binder.rb

@@ -145,6 +145,10 @@ module MilkTea
       return true if receiver_type.is_a?(Types::Matrix)
       return true if receiver_type.is_a?(Types::Quaternion)
       return true if receiver_type.is_a?(Types::SoA)
+      return true if receiver_type.is_a?(Types::Simd)
+      return true if receiver_type.is_a?(Types::Span)
+      return true if receiver_type.is_a?(Types::Task)
+      return true if receiver_type.is_a?(Types::Dyn)
       return true if exported_types.value?(receiver_type)
       return true if imported_receiver_type?(receiver_type, analysis.imports)
       return exported_method_receiver?(receiver_type.base, analysis, exported_types) if receiver_type.is_a?(Types::Nullable)

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

@@ -56,14 +56,22 @@ module MilkTea
         arms
       end
 
+      def parse_match_arm_pattern
+        pattern = parse_bitwise_xor
+        return pattern unless (pattern.is_a?(AST::IntegerLiteral) || pattern.is_a?(AST::CharLiteral)) && match(:dot_dot)
+
+        end_expr = parse_bitwise_xor
+        AST::RangeExpr.new(start_expr: pattern, end_expr:, line: previous.line, column: previous.column)
+      end
+
       def parse_match_expression_arm
         patterns = []
         if match(:else)
           patterns << AST::Identifier.new(name: "_", line: previous.line, column: previous.column)
         else
-          patterns << parse_bitwise_xor
+          patterns << parse_match_arm_pattern
           while match(:pipe)
-            patterns << parse_bitwise_xor
+            patterns << parse_match_arm_pattern
           end
         end
         binding_token = nil
@@ -550,7 +558,7 @@ module MilkTea
       end
 
       def builtin_specialization_target?(expression)
-        expression.is_a?(AST::Identifier) && %w[array reinterpret span zero ptr const_ptr own ref adapt equal hash order].include?(expression.name)
+        expression.is_a?(AST::Identifier) && %w[array reinterpret span zero ptr const_ptr own ref adapt equal hash order simd SoA].include?(expression.name)
       end
 
       def parse_diagnostic_hint?(error)

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

@@ -332,9 +332,9 @@ module MilkTea
         if match(:else)
           patterns << AST::Identifier.new(name: "_", line: previous.line, column: previous.column)
         else
-          patterns << parse_bitwise_xor
+          patterns << parse_match_arm_pattern
           while match(:pipe)
-            patterns << parse_bitwise_xor
+            patterns << parse_match_arm_pattern
           end
         end
         binding_name = if match(:as)

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

@@ -46,8 +46,9 @@ module MilkTea
         raise error(name_token, "expected ':' and parameter type") unless match(:colon)
 
         param_type = parse_type_ref
+        default_value = parse_param_default_value
 
-        AST::Param.new(name: name_token.lexeme, type: param_type, line: name_token.line, column: name_token.column)
+        AST::Param.new(name: name_token.lexeme, type: param_type, line: name_token.line, column: name_token.column, default_value:)
       rescue ParseError => e
         raise unless @recovery_errors
 
@@ -57,6 +58,12 @@ module MilkTea
         AST::Param.new(name: param_name, type: error_type, line: name_token&.line || 1, column: name_token&.column || 1)
       end
 
+      def parse_param_default_value
+        return nil unless match(:equal)
+
+        parse_expression
+      end
+
       def parse_foreign_param
         mode = if foreign_param_qualifier_mode?
                  advance.type

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

@@ -53,6 +53,24 @@ module MilkTea
         struct_type
       end
 
+      def check_simd_construction(simd_type, arguments, scopes:)
+        raise_sema_error("simd construction requires exactly #{simd_type.lane_count} positional arguments, got #{arguments.length}") unless arguments.length == simd_type.lane_count
+        raise_sema_error("simd construction does not accept named arguments") if arguments.any?(&:name)
+
+        element_type = simd_type.element_type
+        arguments.each do |argument|
+          actual_type = infer_expression(argument.value, scopes:, expected_type: element_type)
+          ensure_assignable!(
+            actual_type,
+            element_type,
+            "simd lane expects #{element_type}, got #{actual_type}",
+            expression: argument.value,
+            contextual_int_to_float: contextual_int_to_float_target?(element_type),
+          )
+        end
+        simd_type
+      end
+
       def check_struct_with_call(struct_type, _receiver_expression, arguments, scopes:)
         check_aggregate_field_arguments(struct_type, arguments, scopes:, context: "struct.with()")
         struct_type
@@ -584,6 +602,27 @@ module MilkTea
         end
       end
 
+      def check_simd_method_call(kind, receiver_type, _receiver, arguments, scopes:)
+        raise_sema_error("simd methods do not support named arguments") if arguments.any?(&:name)
+
+        case kind
+        when :simd_lane_with
+          raise_sema_error("with expects exactly 2 arguments, got #{arguments.length}") unless arguments.length == 2
+
+          index_arg = arguments[0].value
+          index_type = infer_expression(index_arg, scopes:)
+          raise_sema_error("with index must be an integer, got #{index_type}") unless index_type.integer?
+
+          value_type = infer_expression(arguments[1].value, scopes:, expected_type: receiver_type.element_type)
+          ensure_assignable!(
+            value_type,
+            receiver_type.element_type,
+            "with expects lane value of type #{receiver_type.element_type}, got #{value_type}",
+          )
+          receiver_type
+        end
+      end
+
       def event_listener_type(event_type)
         params = []
         params << Types::Registry.parameter("value", event_type.payload_type) if event_type.payload_type
@@ -620,6 +659,12 @@ module MilkTea
         ATOMIC_METHOD_KINDS[name]
       end
 
+      def simd_method_kind(receiver_type, name)
+        return unless simd_type?(receiver_type)
+
+        SIMD_METHOD_KINDS[name]
+      end
+
       def check_atomic_method_call(kind, receiver_type, receiver, arguments, scopes:)
         elem_type = atomic_element_type(receiver_type)
         raise_sema_error("atomic methods do not support named arguments") if arguments.any?(&:name)
@@ -740,10 +785,14 @@ module MilkTea
       end
 
       def check_function_call(binding, arguments, scopes:)
-        arguments = canonicalize_call_arguments(arguments, binding.type.params, binding.name)
+        arguments = canonicalize_call_arguments(arguments, binding.type.params, binding.name, binding)
+        fill_positional_defaults!(arguments, binding)
+
         expected_params = binding.type.params
-        unless call_arity_matches?(binding.type, arguments.length)
-          raise_sema_error(arity_error_message(binding.type, binding.name, arguments.length))
+        required_count = count_required_params(binding)
+        variadic = binding.type.is_a?(Types::Function) && binding.type.variadic
+        unless variadic ? arguments.length >= required_count : arguments.length <= expected_params.length && arguments.length >= required_count
+          raise_sema_error(arity_error_message(binding.type, binding.name, arguments.length, required_count:))
         end
 
         expected_params.each_with_index do |parameter, index|
@@ -963,7 +1012,7 @@ module MilkTea
         resolve_interface_ref(interface_ref)
       end
 
-      def canonicalize_call_arguments(arguments, params, context_name)
+      def canonicalize_call_arguments(arguments, params, context_name, binding = nil)
         return arguments unless arguments.any?(&:name)
 
         named_seen = false
@@ -985,8 +1034,52 @@ module MilkTea
           end
         end
 
+        fill_parameter_defaults!(by_position, params, binding, context_name)
+
         by_position.reject(&:nil?)
       end
+
+      def fill_parameter_defaults!(by_position, params, binding, context_name)
+        return unless binding
+
+        ast_params = binding.ast.params
+        return unless ast_params.any? { |p| p.respond_to?(:default_value) && p.default_value }
+
+        params.each_with_index do |param, idx|
+          next unless by_position[idx].nil?
+          next unless idx < ast_params.length
+
+          ast_param = ast_params[idx]
+          next unless ast_param.respond_to?(:default_value) && ast_param.default_value
+
+          by_position[idx] = AST::Argument.new(name: nil, value: ast_param.default_value)
+        end
+      end
+
+      def fill_positional_defaults!(arguments, binding)
+        return unless binding.ast.params.any? { |p| p.respond_to?(:default_value) && p.default_value }
+
+        ast_params = binding.ast.params
+        while arguments.length < ast_params.length
+          ast_param = ast_params[arguments.length]
+          if ast_param.respond_to?(:default_value) && ast_param.default_value
+            arguments << AST::Argument.new(name: nil, value: ast_param.default_value)
+          else
+            break
+          end
+        end
+      end
+
+      def count_required_params(binding)
+        return binding.type.params.length unless binding.ast.params.any? { |p| p.respond_to?(:default_value) && p.default_value }
+
+        seen_default = false
+        binding.ast.params.count do |p|
+          has_default = p.respond_to?(:default_value) && p.default_value
+          seen_default = true if has_default
+          !has_default && !seen_default
+        end
+      end
     end
   end
 end

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

@@ -446,6 +446,10 @@ module MilkTea
           return receiver_type.element_type
         end
 
+        if simd_type?(receiver_type)
+          return receiver_type.element_type
+        end
+
         if array_type?(receiver_type) && !unsafe_context? && !addressable_storage_expression?(expression.receiver, scopes:)
           raise_sema_error("safe array indexing requires an addressable array value; bind it to a local first")
         end
@@ -489,6 +493,10 @@ module MilkTea
 
           operand_type
         when "~"
+          if simd_type?(operand_type)
+            raise_sema_error("operator ~ on simd requires integer element type, got #{operand_type.element_type}") unless operand_type.element_type.integer?
+            return operand_type
+          end
           raise_sema_error("operator ~ requires an integer or flags operand, got #{operand_type}") unless bitwise_type?(operand_type)
 
           operand_type
@@ -596,6 +604,9 @@ module MilkTea
           ensure_assignable!(right_type, @ctx.types.fetch("bool"), "operator #{expression.operator} requires bool operands")
           @ctx.types.fetch("bool")
         when "|", "&", "^"
+          simd_result = simd_bitwise_result(left_type, right_type)
+          return simd_result if simd_result
+
           # For Flags/Enum types, the operands must match and be bitwise-capable.
           unless left_type == right_type && (bitwise_type?(left_type) || left_type.is_a?(Types::Flags))
             raise_sema_error("operator #{expression.operator} requires matching integer or flags types, got #{left_type} and #{right_type}")
@@ -626,6 +637,9 @@ module MilkTea
 
           result_type
         when "%"
+          simd_result = simd_mod_result(left_type, right_type)
+          return simd_result if simd_result
+
           result_type = common_integer_type(left_type, right_type)
           unless result_type
             raise_sema_error("operator % requires compatible integer types, got #{left_type} and #{right_type}")
@@ -633,6 +647,9 @@ module MilkTea
 
           result_type
         when "<<", ">>"
+          simd_result = simd_shift_result(left_type, right_type)
+          return simd_result if simd_result
+
           unless left_type.is_a?(Types::Primitive) && left_type.integer? && right_type.is_a?(Types::Primitive) && right_type.integer?
             raise_sema_error("operator #{expression.operator} requires integer operands, got #{left_type} and #{right_type}")
           end
@@ -787,8 +804,26 @@ module MilkTea
             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
+            arm_entries << [infer_match_expression_arm_value(arm, scopes:, expected_type:), arm.value]
+            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
@@ -1049,8 +1084,12 @@ module MilkTea
           check_event_method_call(callable_kind, receiver, expression.arguments, scopes:)
         when :atomic_load, :atomic_store, :atomic_add, :atomic_sub, :atomic_exchange, :atomic_compare_exchange
           check_atomic_method_call(callable_kind, callable, receiver, expression.arguments, scopes:)
+        when :simd_lane_with
+          check_simd_method_call(callable_kind, callable, receiver, expression.arguments, scopes:)
         when :struct
           check_aggregate_construction(callable, expression.arguments, scopes:)
+        when :simd
+          check_simd_construction(callable, expression.arguments, scopes:)
         when :struct_with
           check_struct_with_call(callable, receiver, expression.arguments, scopes:)
         when :variant_arm_ctor
@@ -1435,6 +1474,10 @@ module MilkTea
             return [atomic_method, method_receiver_type, callee.receiver]
           end
 
+          if (simd_method = simd_method_kind(method_receiver_type, callee.member))
+            return [simd_method, method_receiver_type, callee.receiver]
+          end
+
           field_receiver_type = infer_field_receiver_type(callee.receiver, scopes:)
           if array_type?(field_receiver_type) && callee.member == "as_span"
             return [:array_as_span, field_receiver_type, callee.receiver]
@@ -1467,6 +1510,13 @@ module MilkTea
             return [:array, array_type, nil]
           end
 
+          if callee.callee.is_a?(AST::Identifier) && callee.callee.name == "simd"
+            raise_sema_error("simd requires exactly two type arguments") unless callee.arguments.length == 2
+
+            simd_type = resolve_type_ref(AST::TypeRef.new(name: AST::QualifiedName.new(parts: ["simd"]), arguments: callee.arguments, nullable: false))
+            return [:simd, simd_type, nil]
+          end
+
           if callee.callee.is_a?(AST::Identifier) && callee.callee.name == "span"
             raise_sema_error("span requires exactly one type argument") unless callee.arguments.length == 1
 
@@ -1526,7 +1576,7 @@ module MilkTea
 
           if (type_ref = type_ref_from_specialization(callee))
             specialized_type = resolve_type_ref(type_ref)
-            return [:struct, specialized_type, nil] if specialized_type.is_a?(Types::Struct) || task_type?(specialized_type) || specialized_type.is_a?(Types::Vector) || specialized_type.is_a?(Types::Matrix) || specialized_type.is_a?(Types::Quaternion)
+            return [:struct, specialized_type, nil] if specialized_type.is_a?(Types::Struct) || task_type?(specialized_type) || specialized_type.is_a?(Types::Vector) || specialized_type.is_a?(Types::Matrix) || specialized_type.is_a?(Types::Quaternion) || specialized_type.is_a?(Types::Simd)
           end
 
           raise_sema_error("unsupported callable specialization #{describe_expression(callee)}")

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

@@ -85,6 +85,7 @@ module MilkTea
         end
 
         public_params = []
+        any_default = false
         decl.params.each do |param|
           begin
             ensure_non_reserved_primitive_name!(param.name, kind_label: "parameter", line: param.respond_to?(:line) ? param.line : decl.line, column: param.respond_to?(:column) ? param.column : nil)
@@ -94,6 +95,12 @@ module MilkTea
             validate_parameter_proc_type!(type, function_name: decl.name, parameter_name: param.name, external:, foreign:)
             raise_sema_error("parameter #{param.name} of #{decl.name} must pass event storage through ref[...] or pointers, got #{type}") if noncopyable_event_storage_type?(type)
 
+            has_default = param.respond_to?(:default_value) && param.default_value
+            raise_sema_error("external function #{decl.name} cannot have default parameter values") if external && has_default
+            raise_sema_error("foreign function #{decl.name} cannot have default parameter values") if foreign && has_default
+            raise_sema_error("default parameter #{param.name} of #{decl.name} must appear after required parameters") if !has_default && any_default
+            any_default = true if has_default
+
             if external && array_type?(type)
               raise_sema_error("external function #{decl.name} cannot take array parameters")
             end

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

@@ -45,6 +45,46 @@ module MilkTea
             raise_sema_error("cannot use method #{binding.name} with receiver #{receiver_type}")
           end
         end
+      when Types::Span
+        return {} unless receiver_type.is_a?(Types::Span)
+
+        substitutions = {}
+        if declared_receiver_type.element_type.is_a?(Types::TypeVar)
+          substitutions[declared_receiver_type.element_type.name] = receiver_type.element_type
+        elsif declared_receiver_type.element_type != receiver_type.element_type
+          raise_sema_error("cannot use method #{binding.name} with receiver #{receiver_type}")
+        end
+        substitutions
+      when Types::Task
+        return {} unless receiver_type.is_a?(Types::Task)
+
+        substitutions = {}
+        if declared_receiver_type.result_type.is_a?(Types::TypeVar)
+          substitutions[declared_receiver_type.result_type.name] = receiver_type.result_type
+        elsif declared_receiver_type.result_type != receiver_type.result_type
+          raise_sema_error("cannot use method #{binding.name} with receiver #{receiver_type}")
+        end
+        substitutions
+      when Types::SoA
+        return {} unless receiver_type.is_a?(Types::SoA)
+
+        substitutions = {}
+        if declared_receiver_type.element_type.is_a?(Types::TypeVar)
+          substitutions[declared_receiver_type.element_type.name] = receiver_type.element_type
+        elsif declared_receiver_type.element_type != receiver_type.element_type
+          raise_sema_error("cannot use method #{binding.name} with receiver #{receiver_type}")
+        end
+        substitutions
+      when Types::Simd
+        return {} unless receiver_type.is_a?(Types::Simd)
+
+        substitutions = {}
+        if declared_receiver_type.element_type.is_a?(Types::TypeVar)
+          substitutions[declared_receiver_type.element_type.name] = receiver_type.element_type
+        elsif declared_receiver_type.element_type != receiver_type.element_type
+          raise_sema_error("cannot use method #{binding.name} with receiver #{receiver_type}")
+        end
+        substitutions
       else
         {}
       end