mt-lang 0.4.23 → 0.4.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21ef46a88a5b23f5191412808ad2dfd353d68cead76553908ae5d13c0c773673
-  data.tar.gz: 60cf1b226bb63cb9392d6c54c11c9aead667203d9d103811681aaa43b28c9596
+  metadata.gz: 95423784419c8060f10277cb7abbb1fe1cd955fe648008781d1184976968e2d8
+  data.tar.gz: 6e1b33f4c2a17226dc34ba00618b89be6f329841c5badc7a53ccd022daa3c54d
 SHA512:
-  metadata.gz: a9721db3d74e88c837e15a10657041010b1ff2aba40fee78ebf5c2862375d38121fcb3e3a57a328d3155314a39ba9fb7345b262fc7c99cc12bad41a98d70bc4c
-  data.tar.gz: 4bf9aaa1e0b8a9ba9e5878ab9eece9266e9c386144309abc14f0c47ddc0111dc9de6796f38052e2a956386c159fe9e7c8a0833068e0d084707c133f8e893b9e5
+  metadata.gz: aec1e36ac602ad755b89252058932df48abd25c0e645e212fa404afd25b23679e86d6cf45a970a36d566b08c9be774231496cf59766f64efa366da382e559963
+  data.tar.gz: 85af5d83647fd5cb635bec77a3ae8846be1b6f8f62638b5c82a2f99b9f76f2de6fb08455b6660e0cace75669e9281456a3d7336043ef3009988e50fc3efb4c0c

data/lib/milk_tea/base.rb

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

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.23
+  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.23 installed!
+  Milk Tea 0.4.24 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH