mt-lang 0.2.21 → 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/asset_pack.mt

@@ -50,18 +50,18 @@ public function open(path: str) -> Result[Reader, Error]:
         stdio.file_close(file)
         return Result[Reader, Error].failure(error= Error.invalid_magic)
 
-    let version = decode_u16_le(unsafe: header_ptr + 4)
+    let version = decode_ushort_le(unsafe: header_ptr + 4)
     if version != VERSION:
         stdio.file_close(file)
         return Result[Reader, Error].failure(error= Error.unsupported_version)
 
-    let header_bits = decode_u16_le(unsafe: header_ptr + 6)
+    let header_bits = decode_ushort_le(unsafe: header_ptr + 6)
     if header_bits != HEADER_FLAGS:
         stdio.file_close(file)
         return Result[Reader, Error].failure(error= Error.unsupported_flags)
 
-    let entry_count = decode_u32_le(unsafe: header_ptr + 8)
-    let index_size_result = decode_u64_le(unsafe: header_ptr + 12)
+    let entry_count = decode_uint_le(unsafe: header_ptr + 8)
+    let index_size_result = decode_ulong_le(unsafe: header_ptr + 12)
     var index_size: ptr_uint
     match index_size_result:
         Result.failure as payload:
@@ -70,7 +70,7 @@ public function open(path: str) -> Result[Reader, Error]:
         Result.success as index_payload:
             index_size = index_payload.value
 
-    let data_offset_result = decode_u64_le(unsafe: header_ptr + 20)
+    let data_offset_result = decode_ulong_le(unsafe: header_ptr + 20)
     var data_offset: ptr_uint
     match data_offset_result:
         Result.failure as payload:
@@ -147,12 +147,12 @@ function read_entry_metadata(file: stdio.File?) -> Result[EntryMetadata, Error]:
     if not read_exact(file, prefix_ptr, ENTRY_PREFIX_SIZE_BYTES):
         return Result[EntryMetadata, Error].failure(error= Error.malformed_index)
 
-    let path_length = ptr_uint<-decode_u32_le(prefix_ptr)
+    let path_length = ptr_uint<-decode_uint_le(prefix_ptr)
     if path_length == 0:
         return Result[EntryMetadata, Error].failure(error= Error.malformed_index)
 
-    let entry_bits = decode_u32_le(unsafe: prefix_ptr + 4)
-    let data_offset_result = decode_u64_le(unsafe: prefix_ptr + 8)
+    let entry_bits = decode_uint_le(unsafe: prefix_ptr + 4)
+    let data_offset_result = decode_ulong_le(unsafe: prefix_ptr + 8)
     var data_offset: ptr_uint
     match data_offset_result:
         Result.failure as payload:
@@ -160,7 +160,7 @@ function read_entry_metadata(file: stdio.File?) -> Result[EntryMetadata, Error]:
         Result.success as data_offset_payload:
             data_offset = data_offset_payload.value
 
-    let stored_size_result = decode_u64_le(unsafe: prefix_ptr + 16)
+    let stored_size_result = decode_ulong_le(unsafe: prefix_ptr + 16)
     var stored_size: ptr_uint
     match stored_size_result:
         Result.failure as payload:
@@ -168,7 +168,7 @@ function read_entry_metadata(file: stdio.File?) -> Result[EntryMetadata, Error]:
         Result.success as stored_size_payload:
             stored_size = stored_size_payload.value
 
-    let unpacked_size_result = decode_u64_le(unsafe: prefix_ptr + 24)
+    let unpacked_size_result = decode_ulong_le(unsafe: prefix_ptr + 24)
     var unpacked_size: ptr_uint
     match unpacked_size_result:
         Result.failure as payload:
@@ -228,12 +228,12 @@ function bytes_equal_str(left: ptr[ubyte], left_len: ptr_uint, right: str) -> bo
     return true
 
 
-function decode_u16_le(bytes: ptr[ubyte]) -> uint:
+function decode_ushort_le(bytes: ptr[ubyte]) -> uint:
     unsafe:
         return uint<-read(bytes + 0) | (uint<-read(bytes + 1) << 8)
 
 
-function decode_u32_le(bytes: ptr[ubyte]) -> uint:
+function decode_uint_le(bytes: ptr[ubyte]) -> uint:
     unsafe:
         return (
             uint<-read(bytes + 0) |
@@ -243,7 +243,7 @@ function decode_u32_le(bytes: ptr[ubyte]) -> uint:
         )
 
 
-function decode_u64_le(bytes: ptr[ubyte]) -> Result[ptr_uint, Error]:
+function decode_ulong_le(bytes: ptr[ubyte]) -> Result[ptr_uint, Error]:
     if size_of(ptr[void]) < 8:
         var upper_index: ptr_uint = 4
         while upper_index < 8:

data/std/binary.mt

@@ -114,7 +114,7 @@ extending Writer:
     public editable function write_uint_at(position: ptr_uint, value: uint) -> void:
         let buffer_span = this.buffer.as_span()
         if position + 4 > buffer_span.len:
-            fatal(c"binary.write_u32_at position out of bounds")
+            fatal(c"binary.write_uint_at position out of bounds")
         unsafe:
             read(buffer_span.data + position) = ubyte<-(value & 0xFF)
             read(buffer_span.data + position + 1) = ubyte<-((value >> 8) & 0xFF)

data/std/hash.mt

@@ -189,7 +189,7 @@ extending char:
 #  hash mixes the value's bytes (FNV-1a); equal/order use native operators.
 # ---------------------------------------------------------------------------
 
-function hash_u32(value: uint) -> uint:
+function hash_uint(value: uint) -> uint:
     let fnv: uint = 0x811C9DC5
     let prime: uint = 0x01000193
     var h = fnv
@@ -200,14 +200,14 @@ function hash_u32(value: uint) -> uint:
     return h
 
 
-function hash_u64(value: ulong) -> uint:
-    return hash_u32(uint<-((value >> uint<-(32)) ^ value))
+function hash_ulong(value: ulong) -> uint:
+    return hash_uint(uint<-((value >> uint<-(32)) ^ value))
 
 
 extending byte:
     public static function hash(value: const_ptr[byte]) -> uint:
         unsafe:
-            return hash_u32(uint<-(int<-read(ptr[byte]<-value)))
+            return hash_uint(uint<-(int<-read(ptr[byte]<-value)))
 
 
     public static function equal(a: const_ptr[byte], b: const_ptr[byte]) -> bool:
@@ -229,7 +229,7 @@ extending byte:
 extending ubyte:
     public static function hash(value: const_ptr[ubyte]) -> uint:
         unsafe:
-            return hash_u32(uint<-read(ptr[ubyte]<-value))
+            return hash_uint(uint<-read(ptr[ubyte]<-value))
 
 
     public static function equal(a: const_ptr[ubyte], b: const_ptr[ubyte]) -> bool:
@@ -251,7 +251,7 @@ extending ubyte:
 extending short:
     public static function hash(value: const_ptr[short]) -> uint:
         unsafe:
-            return hash_u32(uint<-(int<-read(ptr[short]<-value)))
+            return hash_uint(uint<-(int<-read(ptr[short]<-value)))
 
 
     public static function equal(a: const_ptr[short], b: const_ptr[short]) -> bool:
@@ -273,7 +273,7 @@ extending short:
 extending ushort:
     public static function hash(value: const_ptr[ushort]) -> uint:
         unsafe:
-            return hash_u32(uint<-read(ptr[ushort]<-value))
+            return hash_uint(uint<-read(ptr[ushort]<-value))
 
 
     public static function equal(a: const_ptr[ushort], b: const_ptr[ushort]) -> bool:
@@ -295,7 +295,7 @@ extending ushort:
 extending long:
     public static function hash(value: const_ptr[long]) -> uint:
         unsafe:
-            return hash_u64(ulong<-read(ptr[long]<-value))
+            return hash_ulong(ulong<-read(ptr[long]<-value))
 
 
     public static function equal(a: const_ptr[long], b: const_ptr[long]) -> bool:
@@ -317,7 +317,7 @@ extending long:
 extending ulong:
     public static function hash(value: const_ptr[ulong]) -> uint:
         unsafe:
-            return hash_u64(read(ptr[ulong]<-value))
+            return hash_ulong(read(ptr[ulong]<-value))
 
 
     public static function equal(a: const_ptr[ulong], b: const_ptr[ulong]) -> bool:
@@ -339,7 +339,7 @@ extending ulong:
 extending ptr_int:
     public static function hash(value: const_ptr[ptr_int]) -> uint:
         unsafe:
-            return hash_u64(ulong<-read(ptr[ptr_int]<-value))
+            return hash_ulong(ulong<-read(ptr[ptr_int]<-value))
 
 
     public static function equal(a: const_ptr[ptr_int], b: const_ptr[ptr_int]) -> bool:
@@ -410,7 +410,7 @@ public function order_struct[T](a: const_ptr[T], b: const_ptr[T]) -> int:
 extending ptr_uint:
     public static function hash(value: const_ptr[ptr_uint]) -> uint:
         unsafe:
-            return hash_u64(ulong<-read(ptr[ptr_uint]<-value))
+            return hash_ulong(ulong<-read(ptr[ptr_uint]<-value))
 
 
     public static function equal(a: const_ptr[ptr_uint], b: const_ptr[ptr_uint]) -> bool:

data/std/net/session.mt

@@ -167,7 +167,7 @@ function generate_handshake_key() -> Result[ulong, net.Error]:
                     return Result[ulong, net.Error].success(value = value)
 
 
-function decode_u32_at(data: span[ubyte], offset: ptr_uint) -> uint:
+function decode_uint_at(data: span[ubyte], offset: ptr_uint) -> uint:
     unsafe:
         return uint<-read(data.data + offset) | (uint<-read(data.data + offset + 1) << 8) | (uint<-read(data.data + offset + 2) << 16) | (uint<-read(data.data + offset + 3) << 24)
 
@@ -536,7 +536,7 @@ function handle_incoming_conn(conn: ref[Connection], msg: ref[chan.Message]) ->
         conn.frame_since_last_recv = 0
         let hb_span = unsafe: span[ubyte](data = span.data + 1, len = span.len - 1)
         if hb_span.len >= 4:
-            let echoed = decode_u32_at(hb_span, 0)
+            let echoed = decode_uint_at(hb_span, 0)
             var ack = build_heartbeat_ack(echoed)
             let peer_addr_result = conn.channel.peer_address()
             match peer_addr_result:
@@ -555,7 +555,7 @@ function handle_incoming_conn(conn: ref[Connection], msg: ref[chan.Message]) ->
         conn.frame_since_last_recv = 0
         let echo_span = unsafe: span[ubyte](data = span.data + 1, len = span.len - 1)
         if echo_span.len >= 4:
-            let echoed = decode_u32_at(echo_span, 0)
+            let echoed = decode_uint_at(echo_span, 0)
             if conn.last_heartbeat_sent > echoed:
                 conn.ping_rtt_frames = conn.last_heartbeat_sent - echoed
         msg.release()
@@ -920,7 +920,7 @@ function handle_incoming_session(session: ref[Session], msg: ref[chan.HostMessag
                 update_peer_last_recv(session, peer_payload.value)
                 let hb_span = unsafe: span[ubyte](data = span.data + 1, len = span.len - 1)
                 if hb_span.len >= 4:
-                    let echoed = decode_u32_at(hb_span, 0)
+                    let echoed = decode_uint_at(hb_span, 0)
                     var ack = build_heartbeat_ack(echoed)
                     let addr_result = msg.source.copy()
                     match addr_result:
@@ -973,7 +973,7 @@ function handle_connect_request(session: ref[Session], msg: ref[chan.HostMessage
         msg.release()
         return
 
-    let client_version = decode_u32_at(req_span, 0)
+    let client_version = decode_uint_at(req_span, 0)
     if client_version != session.config.protocol_version:
         var reject = build_connect_reject(reject_reason_version)
         let addr_result = msg.source.copy()