mt-lang 0.4.22 → 0.4.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60f503669467624ebec5461f2f5fb5c3dae9216718b4c445f182323b90e9f505
-  data.tar.gz: d5ace59e3fdadbe3a7ea75f740d0d1d2953088d1799b42e9e6899c900e50595a
+  metadata.gz: 95423784419c8060f10277cb7abbb1fe1cd955fe648008781d1184976968e2d8
+  data.tar.gz: 6e1b33f4c2a17226dc34ba00618b89be6f329841c5badc7a53ccd022daa3c54d
 SHA512:
-  metadata.gz: e74f76c097577a41ccc21462f7ede0d2c2a77f84f883e0ca3026b6b3f966e4b87ba3cfc91eca5dc16165edbc50a6f2bcff6be7ef6be751a1ba95f86b472b6e00
-  data.tar.gz: 652e7de9f0afd01aeac1358af1c47a2a19bce244ec53838b5cfc65b103d44cafea61210d01ca766bf390d4b649268d50d6ac2c057ce40e09f64e25b24c4a3d76
+  metadata.gz: aec1e36ac602ad755b89252058932df48abd25c0e645e212fa404afd25b23679e86d6cf45a970a36d566b08c9be774231496cf59766f64efa366da382e559963
+  data.tar.gz: 85af5d83647fd5cb635bec77a3ae8846be1b6f8f62638b5c82a2f99b9f76f2de6fb08455b6660e0cace75669e9281456a3d7336043ef3009988e50fc3efb4c0c

data/bin/mtc

@@ -3,6 +3,8 @@
 
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 
+RubyVM::YJIT.enable if defined?(RubyVM::YJIT.enable) && !RubyVM::YJIT.enabled?
+
 require "milk_tea"
 
 exit(MilkTea::CLI.start(ARGV))

data/lib/milk_tea/base.rb

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

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

@@ -188,6 +188,7 @@ module MilkTea
         return lower_str_buffer_to_span_expression(lowered, expected_type) if str_buffer_to_span_compatible?(lowered.type, expected_type)
         return lower_array_to_span_expression(lowered, expected_type) if array_to_span_compatible?(lowered.type, expected_type)
         return cast_expression(lowered, expected_type) if contextual_numeric_compatibility?(expression, lowered.type, expected_type, env:, external_numeric:, contextual_int_to_float:)
+        return wrap_nullable_field_value(expected_type, lowered, env) if expected_type.is_a?(Types::Nullable) && lowered.type == expected_type.base
 
         lowered
       end

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

@@ -10,11 +10,11 @@ module MilkTea
     POINTER_SIZE = Fiddle::SIZEOF_VOIDP
 
     def self.size_of(type)
-      size_and_alignment(type, {})&.first
+      size_and_alignment(type, nil)&.first
     end
 
     def self.alignment_of(type)
-      size_and_alignment(type, {})&.last
+      size_and_alignment(type, nil)&.last
     end
 
     def self.offset_of(type, field_name)
@@ -38,6 +38,14 @@ module MilkTea
       end
     end
 
+    # Computes [size, alignment] for a type.
+    #
+    # `stack` carries the aggregates on the current root-to-leaf path,
+    # pass-down only (never popped). A field whose type reaches any aggregate
+    # on that path participates in a storage cycle, and the C backend embeds
+    # exactly those fields as pointers (see
+    # CBackend#build_cyclic_aggregate_pairs and the cyclic field emission in
+    # type_declaration.rb), so layout sizes back-edge fields as raw pointers.
     def self.size_and_alignment(type, stack)
       case type
       when Types::Primitive
@@ -48,24 +56,24 @@ module MilkTea
         if type.is_a?(Types::Function) || layout_pointer_like_nullable_base?(type.base)
           [POINTER_SIZE, POINTER_SIZE]
         else
-          with_stack(type, stack) do
-            layout = struct_layout(nullable_opt_layout_fields(type.base), packed: false, alignment: nil, stack:)
+          with_stack(type, stack) do |next_stack|
+            layout = struct_layout(nullable_opt_layout_fields(type.base), packed: false, alignment: nil, stack: next_stack)
             [layout[:size], layout[:alignment]]
           end
         end
       when Types::StringView, Types::Span, Types::Task, Types::Struct, Types::StructInstance
-        with_stack(type, stack) do
-          layout = struct_layout(ordered_fields(type), packed: packed_layout?(type), alignment: explicit_alignment(type), stack:)
+        with_stack(type, stack) do |next_stack|
+          layout = struct_layout(ordered_fields(type), packed: packed_layout?(type), alignment: explicit_alignment(type), stack: next_stack)
           [layout[:size], layout[:alignment]]
         end
       when Types::Union
-        with_stack(type, stack) do
-          layout = union_layout(ordered_fields(type), packed: packed_layout?(type), alignment: explicit_alignment(type), stack:)
+        with_stack(type, stack) do |next_stack|
+          layout = union_layout(ordered_fields(type), packed: packed_layout?(type), alignment: explicit_alignment(type), stack: next_stack)
           [layout[:size], layout[:alignment]]
         end
       when Types::Variant, Types::VariantInstance
-        with_stack(type, stack) do
-          layout = variant_layout(type, stack:)
+        with_stack(type, stack) do |next_stack|
+          layout = variant_layout(type, stack: next_stack)
           [layout[:size], layout[:alignment]]
         end
       when Types::GenericInstance
@@ -128,8 +136,8 @@ module MilkTea
       when "str_buffer"
         return unless str_buffer_type?(type)
 
-        with_stack(type, stack) do
-          layout = struct_layout(str_buffer_fields(type), packed: false, alignment: nil, stack:)
+        with_stack(type, stack) do |next_stack|
+          layout = struct_layout(str_buffer_fields(type), packed: false, alignment: nil, stack: next_stack)
           [layout[:size], layout[:alignment]]
         end
       end
@@ -151,7 +159,7 @@ module MilkTea
 
     def self.struct_layout(fields, packed:, alignment:, stack:)
       field_infos = fields.map do |field_name, field_type|
-        field_layout = size_and_alignment(field_type, stack)
+        field_layout = field_size_and_alignment(field_type, stack)
         return nil unless field_layout
 
         [field_name, field_layout.first, field_layout.last]
@@ -162,7 +170,7 @@ module MilkTea
 
     def self.union_layout(fields, packed:, alignment:, stack:)
       field_infos = fields.map do |_field_name, field_type|
-        field_layout = size_and_alignment(field_type, stack)
+        field_layout = field_size_and_alignment(field_type, stack)
         return nil unless field_layout
 
         field_layout
@@ -171,6 +179,30 @@ module MilkTea
       union_layout_from_layouts(field_infos.map { |size, field_alignment| { size:, alignment: field_alignment } }, packed:, alignment:)
     end
 
+    # A field whose type reaches any aggregate on the current path is a
+    # storage-cycle back edge. The C backend emits such fields as pointers
+    # (element pointer for arrays), so they occupy pointer-size storage here.
+    def self.field_size_and_alignment(field_type, stack)
+      return [POINTER_SIZE, POINTER_SIZE] if cyclic_back_edge?(field_type, stack)
+
+      size_and_alignment(field_type, stack)
+    end
+
+    def self.cyclic_back_edge?(field_type, stack)
+      return false if stack.nil? || stack.empty?
+
+      aggregate_reaches_in_progress?(field_type, stack, {})
+    end
+
+    def self.aggregate_reaches_in_progress?(type, stack, visited)
+      return false if visited.key?(type.object_id)
+
+      visited[type.object_id] = true
+      return true if stack.key?(type)
+
+      reachability_children(type).any? { |child| aggregate_reaches_in_progress?(child, stack, visited) }
+    end
+
     def self.struct_layout_from_infos(field_infos, packed:, alignment:)
       offsets = {}
       offset = 0
@@ -253,13 +285,52 @@ module MilkTea
       remainder.zero? ? value : value + alignment - remainder
     end
 
+    # `stack` is the set of aggregates on the current path, pass-down only.
+    # A nil or empty stack means the caller is not inside an aggregate yet.
+    # Yields the extended stack; returns nil when `type` is already in progress
+    # (callers treat that as unreachable while mirroring backend semantics).
     def self.with_stack(type, stack)
-      return if stack[type]
+      next_stack = (stack || {}).dup
+      return nil if next_stack.key?(type)
+
+      next_stack[type] = true
+      yield(next_stack)
+    end
+
+    # Structural expansion used for back-edge detection. Mirrors the
+    # CBackend's `aggregate_type_dependencies` so pointer-broken cyclic
+    # fields agree with the emitted C struct layout.
+    def self.reachability_children(type)
+      case type
+      when Types::Nullable
+        [type.base]
+      when Types::GenericInstance
+        if pointer_type?(type)
+          []
+        elsif array_type?(type)
+          [array_element_type(type)]
+        else
+          []
+        end
+      when Types::Span
+        [type.element_type]
+      when Types::Struct, Types::StructInstance, Types::Union
+        type.fields.values
+      when Types::Variant, Types::VariantInstance
+        type.arm_names.flat_map { |name| type.arm(name).values }
+      when Types::VariantArmPayload
+        type.fields.values
+      else
+        []
+      end
+    end
+
+    def self.pointer_type?(type)
+      type.is_a?(Types::GenericInstance) && %w[ptr const_ptr own ref].include?(type.name)
+    end
 
-      stack[type] = true
-      yield
-    ensure
-      stack.delete(type)
+    def self.array_element_type(type)
+      type.arguments.first
     end
     end
   end

data/std/vec.mt

@@ -348,6 +348,7 @@ extending Iter[T]:
                 total += 1
 
 
+extending Vec[T]:
     public editable function sort() -> void:
         if this.len <= 1:
             return

metadata

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