mt-lang 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e212444d219545cf86e5711bdcd0eb02028b94fd8b0ae1ac8b6ade08b25967da
-  data.tar.gz: fce0d6413dfc434af53103228604527bf9f08fef30dcbd7013fd50f5bd30878b
+  metadata.gz: ed7c9f0e80bb1fcfc3b458b277a0a2eda3b55ca295950af89c99a769b74e4be2
+  data.tar.gz: 4eb3fdfcbdb1557b3ed87a1f60ce8704f1f1de943e58e2c096318fc802da55a2
 SHA512:
-  metadata.gz: acc176d3ad35b7184b3df7e4beb4fb6a411bcf613bc7905fa16f215388d0ff26a6a0cea201f124f861f571efa7166098e969cffbe5e600ccf2e30614c5351065
-  data.tar.gz: 7664d2ceb6235804d8ee78e6dd594ece82492f2e1d00c792762c696d122e3ad669b57dd4825acbada2c5d83dcb1fddef0b366dacd2f363d475bbedefba6122a9
+  metadata.gz: f900ebf361a8f2c8acec00fb63ccae9d6b23cd6059ba2edc27b4a3c89fe288453498d9aca753cba2b1139db6b69a82e52038e976c5d4b692d052845735afd754
+  data.tar.gz: 0a2bffc30d6485314ef351fb3917696298978798494e8eb655b27ed045c2d0c74674ab53d2c8b8764241b1e07fef092c3bbd6b35b73451d0237ac250a4d7a21c

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/tooling/linter/imports_platform.rb

@@ -18,6 +18,7 @@ module MilkTea
           local_name = import.alias_name || import.path.parts.last
           next if ignored_binding_name?(local_name)
           next if used.include?(local_name)
+          next if import_provides_extending_methods?(import)
 
           @warnings << Warning.new(
             path: @path,
@@ -31,6 +32,15 @@ module MilkTea
         end
       end
 
+      def import_provides_extending_methods?(import)
+        return false unless @sema_facts.respond_to?(:imports)
+
+        module_binding = @sema_facts.imports[import.alias_name || import.path.parts.last]
+        return false unless module_binding&.respond_to?(:methods)
+
+        module_binding.methods.any?
+      end
+
       def check_platform_api_drift(source_file)
         resolved_path = self.class.resolve_lint_path(@path)
         return unless resolved_path&.end_with?(".mt")

data/lib/milk_tea/tooling/linter/release_rules.rb

@@ -239,16 +239,37 @@ module MilkTea
             true
           elsif stmt.is_a?(AST::Assignment) && stmt.value.is_a?(AST::Identifier) && stmt.value.name == name
             true
+          elsif stmt.is_a?(AST::ReturnStmt) && own_cast_in_unsafe?(stmt.value, name)
+            true
           else
             false
           end
         end
       end
 
+      def own_cast_in_unsafe?(expr, name)
+        case expr
+        when AST::UnsafeExpr
+          case expr.expression
+          when AST::PrefixCast
+            expr.expression.expression.is_a?(AST::Identifier) && expr.expression.expression.name == name
+          end
+        else
+          false
+        end
+      end
+
       def own_struct_field_transfer?(expr, name)
-        return false unless expr.is_a?(AST::Call)
-        expr.arguments.any? do |arg|
-          arg.is_a?(AST::Argument) && arg.value.is_a?(AST::Identifier) && arg.value.name == name
+        case expr
+        when AST::Call
+          expr.arguments.any? do |arg|
+            next unless arg.is_a?(AST::Argument)
+
+            arg.value.is_a?(AST::Identifier) && arg.value.name == name ||
+              own_struct_field_transfer?(arg.value, name)
+          end
+        else
+          false
         end
       end
 

data/lib/milk_tea/tooling/linter/visitors.rb

@@ -152,6 +152,7 @@ module MilkTea
             column: statement.column,
             var: statement.kind == :var
           )
+          with_scope { visit_statement_list(statement.else_body) } if statement.else_body
           check_redundant_type_annotation(statement)
           flag_redundant_widening_cast(statement.value) if statement.type && statement.value
           record_ptr_candidate(statement)

data/std/iter.mt

@@ -0,0 +1,304 @@
+## std.iter — composable, lazy iteration adaptors.
+##
+## Each source/adaptor creates heap-allocated state linked through
+## function pointers. Release walks the chain to free all allocations.
+## Callbacks use fn types (function pointers, no captures).
+##
+## iter_map stores the mapped value inline in the adaptor state and
+## returns a pointer to it — no per-item allocation.
+##
+## Usage:
+##   import std.iter
+##   let it = iter.from_array(ref_of(arr))
+##   let it2 = iter.iter_filter(it, pred)
+##   let v = iter.collect_vec(it2)
+
+import std.mem.heap as heap
+import std.mem.ptr as ptr
+import std.vec as v
+
+## ── Core Iter type ───────────────────────────────────────────────────
+
+struct Iter[T]:
+    state: ptr[void]
+    next_fn: fn(state: ptr[void]) -> ptr[T]?
+    release_fn: fn(state: ptr[void]) -> void
+
+## ── Ownership helpers ────────────────────────────────────────────────
+
+public function own_to_ptr[T](owned: own[T]) -> ptr[void]:
+    return unsafe: ptr[void]<-owned
+
+## ── Source: Vec ─────────────────────────────────────────────────────
+
+public function from_vec[T](vec: ref[v.Vec[T]]) -> Iter[T]:
+    return from_span(vec.as_span())
+
+## ── Source: array ────────────────────────────────────────────────────
+
+public function from_array[T, N](arr: ref[array[T, N]]) -> Iter[T]:
+    return from_span(arr.as_span())
+
+## ── .as_iter() extending blocks ──────────────────────────────────────
+
+extending v.Vec[T]:
+    public editable function as_iter() -> Iter[T]:
+        return from_vec(ref_of(this))
+
+extending array[T, N]:
+    public editable function as_iter() -> Iter[T]:
+        return from_array[T, N](ref_of(this))
+
+extending span[T]:
+    public function as_iter() -> Iter[T]:
+        return from_span(this)
+
+## ── Source: span ─────────────────────────────────────────────────────
+
+struct SpanIterState[T]:
+    sp: span[T]
+    index: ptr_uint
+
+public function span_advance[T](state: ptr[void]) -> ptr[T]?:
+    let s = unsafe: ptr[SpanIterState[T]]<-state
+    let _this = unsafe: read(s)
+    if _this.index >= _this.sp.len:
+        return null
+    let item = unsafe: _this.sp.data + _this.index
+    unsafe: read(s).index += 1
+    return item
+
+public function span_release[T](state: ptr[void]) -> void:
+    let s = unsafe: ptr[SpanIterState[T]]<-state
+    heap.release[SpanIterState[T]](s)
+
+public function from_span[T](sp: span[T]) -> Iter[T]:
+    let state = heap.must_alloc[SpanIterState[T]](1)
+    state.index = 0
+    state.sp = sp
+    let p = own_to_ptr(state)
+    return Iter[T](state = p, next_fn = span_advance[T], release_fn = span_release[T])
+
+## ── Adaptor: Filter ──────────────────────────────────────────────────
+
+struct FilterState[T]:
+    inner: Iter[T]
+    pred: fn(value: T) -> bool
+
+public function filter_advance[T](state: ptr[void]) -> ptr[T]?:
+    let s = unsafe: ptr[FilterState[T]]<-state
+    let _this = unsafe: read(s)
+    var item = _this.inner.next_fn(_this.inner.state)
+    while item != null:
+        if _this.pred(item.load()):
+            return item
+        item = _this.inner.next_fn(_this.inner.state)
+    return null
+
+public function filter_release[T](state: ptr[void]) -> void:
+    let s = unsafe: ptr[FilterState[T]]<-state
+    let _this = unsafe: read(s)
+    _this.inner.release_fn(_this.inner.state)
+    heap.release[FilterState[T]](s)
+
+public function iter_filter[T](iter: Iter[T], pred: fn(value: T) -> bool) -> Iter[T]:
+    let state = heap.must_alloc[FilterState[T]](1)
+    state.inner = iter
+    state.pred = pred
+    let p = own_to_ptr(state)
+    return Iter[T](state = p, next_fn = filter_advance[T], release_fn = filter_release[T])
+
+## ── Adaptor: Map ─────────────────────────────────────────────────────
+
+struct MapState[T, U]:
+    inner: Iter[T]
+    map_fn: fn(value: T) -> U
+    current: U
+
+public function map_advance[T, U](state: ptr[void]) -> ptr[U]?:
+    let s = unsafe: ptr[MapState[T, U]]<-state
+    let current_offset = offset_of(MapState[T, U], current)
+    let p = unsafe: read(s)
+    let item = p.inner.next_fn(p.inner.state) else:
+        return null
+    let base: ptr[ubyte] = unsafe: ptr[ubyte]<-s
+    let field_ptr = unsafe: base + ptr_uint<-current_offset
+    let target: ptr[U] = unsafe: ptr[U]<-field_ptr
+    target.store(p.map_fn(item.load()))
+    return target
+
+public function map_release[T, U](state: ptr[void]) -> void:
+    let s = unsafe: ptr[MapState[T, U]]<-state
+    let _this = unsafe: read(s)
+    _this.inner.release_fn(_this.inner.state)
+    heap.release[MapState[T, U]](s)
+
+public function iter_map[T, U](iter: Iter[T], f: fn(value: T) -> U) -> Iter[U]:
+    let state = heap.must_alloc[MapState[T, U]](1)
+    state.inner = iter
+    state.map_fn = f
+    let p = own_to_ptr(state)
+    return Iter[U](state = p, next_fn = map_advance[T, U], release_fn = map_release[T, U])
+
+## ── Adaptor: Take ────────────────────────────────────────────────────
+
+struct TakeState[T]:
+    inner: Iter[T]
+    remaining: int
+
+public function take_advance[T](state: ptr[void]) -> ptr[T]?:
+    let s = unsafe: ptr[TakeState[T]]<-state
+    let _this = unsafe: read(s)
+    if _this.remaining <= 0:
+        return null
+    unsafe: read(s).remaining -= 1
+    return _this.inner.next_fn(_this.inner.state)
+
+public function take_release[T](state: ptr[void]) -> void:
+    let s = unsafe: ptr[TakeState[T]]<-state
+    let _this = unsafe: read(s)
+    _this.inner.release_fn(_this.inner.state)
+    heap.release[TakeState[T]](s)
+
+public function iter_take[T](iter: Iter[T], n: int) -> Iter[T]:
+    let state = heap.must_alloc[TakeState[T]](1)
+    state.inner = iter
+    state.remaining = n
+    let p = own_to_ptr(state)
+    return Iter[T](state = p, next_fn = take_advance[T], release_fn = take_release[T])
+
+## ── Adaptor: Skip ────────────────────────────────────────────────────
+
+struct SkipState[T]:
+    inner: Iter[T]
+    skip_count: int
+
+public function skip_advance[T](state: ptr[void]) -> ptr[T]?:
+    let s = unsafe: ptr[SkipState[T]]<-state
+    let _this = unsafe: read(s)
+    while _this.skip_count > 0:
+        let _ = _this.inner.next_fn(_this.inner.state) else:
+            return null
+        unsafe: read(s).skip_count -= 1
+    return _this.inner.next_fn(_this.inner.state)
+
+public function skip_release[T](state: ptr[void]) -> void:
+    let s = unsafe: ptr[SkipState[T]]<-state
+    let _this = unsafe: read(s)
+    _this.inner.release_fn(_this.inner.state)
+    heap.release[SkipState[T]](s)
+
+public function iter_skip[T](iter: Iter[T], n: int) -> Iter[T]:
+    let state = heap.must_alloc[SkipState[T]](1)
+    state.inner = iter
+    state.skip_count = n
+    let p = own_to_ptr(state)
+    return Iter[T](state = p, next_fn = skip_advance[T], release_fn = skip_release[T])
+
+## ── Adaptor: Enumerate ────────────────────────────────────────────────
+
+struct Enumerated[T]:
+    index: ptr_uint
+    value: T
+
+struct EnumerateState[T]:
+    inner: Iter[T]
+    index: ptr_uint
+    current: Enumerated[T]
+
+public function enum_advance[T](state: ptr[void]) -> ptr[Enumerated[T]]?:
+    let s = unsafe: ptr[EnumerateState[T]]<-state
+    let current_offset = offset_of(EnumerateState[T], current)
+    let p = unsafe: read(s)
+    let item = p.inner.next_fn(p.inner.state) else:
+        return null
+    let base: ptr[ubyte] = unsafe: ptr[ubyte]<-s
+    let field_ptr = unsafe: base + ptr_uint<-current_offset
+    let target: ptr[Enumerated[T]] = unsafe: ptr[Enumerated[T]]<-field_ptr
+    target.store(Enumerated[T](index = p.index, value = item.load()))
+    unsafe: read(s).index += 1
+    return target
+
+public function enum_release[T](state: ptr[void]) -> void:
+    let s = unsafe: ptr[EnumerateState[T]]<-state
+    let _this = unsafe: read(s)
+    _this.inner.release_fn(_this.inner.state)
+    heap.release[EnumerateState[T]](s)
+
+public function iter_enumerate[T](iter: Iter[T]) -> Iter[Enumerated[T]]:
+    let state = heap.must_alloc[EnumerateState[T]](1)
+    state.inner = iter
+    state.index = 0
+    let p = own_to_ptr(state)
+    let enum_it = Iter[Enumerated[T]](state = p, next_fn = enum_advance[T], release_fn = enum_release[T])
+    return enum_it
+
+## ── Consumer: Fold ───────────────────────────────────────────────────
+
+public function iter_fold[T, U](iter: Iter[T], init: U, f: fn(accum: U, value: T) -> U) -> U:
+    var accum = init
+    var item = iter.next_fn(iter.state)
+    while item != null:
+        accum = f(accum, item.load())
+        item = iter.next_fn(iter.state)
+    iter.release_fn(iter.state)
+    return accum
+
+## ── Consumer: Find ───────────────────────────────────────────────────
+
+public function iter_find[T](iter: Iter[T], pred: fn(value: T) -> bool) -> Option[T]:
+    var item = iter.next_fn(iter.state)
+    while item != null:
+        if pred(item.load()):
+            let val = item.load()
+            iter.release_fn(iter.state)
+            return Option[T].some(value = val)
+        item = iter.next_fn(iter.state)
+    iter.release_fn(iter.state)
+    return Option[T].none
+
+## ── Consumer: Any ────────────────────────────────────────────────────
+
+public function iter_any[T](iter: Iter[T], pred: fn(value: T) -> bool) -> bool:
+    var item = iter.next_fn(iter.state)
+    while item != null:
+        if pred(item.load()):
+            iter.release_fn(iter.state)
+            return true
+        item = iter.next_fn(iter.state)
+    iter.release_fn(iter.state)
+    return false
+
+## ── Consumer: All ────────────────────────────────────────────────────
+
+public function iter_all[T](iter: Iter[T], pred: fn(value: T) -> bool) -> bool:
+    var item = iter.next_fn(iter.state)
+    while item != null:
+        if not pred(item.load()):
+            iter.release_fn(iter.state)
+            return false
+        item = iter.next_fn(iter.state)
+    iter.release_fn(iter.state)
+    return true
+
+## ── Consumer: Count ──────────────────────────────────────────────────
+
+public function iter_count[T](iter: Iter[T]) -> ptr_uint:
+    var count: ptr_uint = 0
+    var item = iter.next_fn(iter.state)
+    while item != null:
+        count += 1
+        item = iter.next_fn(iter.state)
+    iter.release_fn(iter.state)
+    return count
+
+## ── Collect: Vec ─────────────────────────────────────────────────────
+
+public function collect_vec[T](iter: Iter[T]) -> v.Vec[T]:
+    var result = v.Vec[T].create()
+    var item = iter.next_fn(iter.state)
+    while item != null:
+        result.push(item.load())
+        item = iter.next_fn(iter.state)
+    iter.release_fn(iter.state)
+    return result

data/std/mem/ptr.mt

@@ -0,0 +1,12 @@
+## Pointer load/store — safe wrappers around unsafe: read(ptr).
+##
+##   import std.mem.ptr as ptr
+##   p.store(42)
+##   let v = p.load()
+
+extending ptr[T]:
+    public function load() -> T:
+        return unsafe: read(this)
+
+    public function store(value: T) -> void:
+        unsafe: read(this) = value

data/std/simd.mt

@@ -0,0 +1,100 @@
+## SIMD helpers — load, store, and reduction operations
+## for the built-in simd[T, N] type constructor.
+##
+## Load and store use unsafe ptr casts internally; the user-facing
+## surface is safe because only valid pointer dereferencing is involved.
+##
+## Usage:
+##   import std.simd as simd
+##   let v = simd.load_aligned_float4(ptr)
+##   let s = simd.horizontal_sum_float4(v)
+
+import std.mem.ptr as ptr
+
+## ── simd[float, 4] ──────────────────────────────────────────────────
+
+public function load_aligned_float4(p: ptr[float]) -> simd[float, 4]:
+    let sp = unsafe: ptr[simd[float, 4]]<-p
+    return sp.load()
+
+public function load_unaligned_float4(p: ptr[float]) -> simd[float, 4]:
+    return load_aligned_float4(p)
+
+public function store_aligned_float4(p: ptr[float], value: simd[float, 4]) -> void:
+    let sp = unsafe: ptr[simd[float, 4]]<-p
+    sp.store(value)
+
+public function store_unaligned_float4(p: ptr[float], value: simd[float, 4]) -> void:
+    store_aligned_float4(p, value)
+
+public function horizontal_sum_float4(v: simd[float, 4]) -> float:
+    return v[0] + v[1] + v[2] + v[3]
+
+public function dot_float4(a: simd[float, 4], b: simd[float, 4]) -> float:
+    return horizontal_sum_float4(a * b)
+
+## ── simd[int, 4] ────────────────────────────────────────────────────
+
+public function load_aligned_int4(p: ptr[int]) -> simd[int, 4]:
+    let sp = unsafe: ptr[simd[int, 4]]<-p
+    return sp.load()
+
+public function load_unaligned_int4(p: ptr[int]) -> simd[int, 4]:
+    return load_aligned_int4(p)
+
+public function store_aligned_int4(p: ptr[int], value: simd[int, 4]) -> void:
+    let sp = unsafe: ptr[simd[int, 4]]<-p
+    sp.store(value)
+
+public function store_unaligned_int4(p: ptr[int], value: simd[int, 4]) -> void:
+    store_aligned_int4(p, value)
+
+public function horizontal_sum_int4(v: simd[int, 4]) -> int:
+    return v[0] + v[1] + v[2] + v[3]
+
+public function dot_int4(a: simd[int, 4], b: simd[int, 4]) -> int:
+    return horizontal_sum_int4(a * b)
+
+## ── simd[float, 8] (AVX) ────────────────────────────────────────────
+
+public function load_aligned_float8(p: ptr[float]) -> simd[float, 8]:
+    let sp = unsafe: ptr[simd[float, 8]]<-p
+    return sp.load()
+
+public function load_unaligned_float8(p: ptr[float]) -> simd[float, 8]:
+    return load_aligned_float8(p)
+
+public function store_aligned_float8(p: ptr[float], value: simd[float, 8]) -> void:
+    let sp = unsafe: ptr[simd[float, 8]]<-p
+    sp.store(value)
+
+public function store_unaligned_float8(p: ptr[float], value: simd[float, 8]) -> void:
+    store_aligned_float8(p, value)
+
+public function horizontal_sum_float8(v: simd[float, 8]) -> float:
+    return v[0] + v[1] + v[2] + v[3] + v[4] + v[5] + v[6] + v[7]
+
+public function dot_float8(a: simd[float, 8], b: simd[float, 8]) -> float:
+    return horizontal_sum_float8(a * b)
+
+## ── simd[double, 2] ─────────────────────────────────────────────────
+
+public function load_aligned_double2(p: ptr[double]) -> simd[double, 2]:
+    let sp = unsafe: ptr[simd[double, 2]]<-p
+    return sp.load()
+
+public function load_unaligned_double2(p: ptr[double]) -> simd[double, 2]:
+    return load_aligned_double2(p)
+
+public function store_aligned_double2(p: ptr[double], value: simd[double, 2]) -> void:
+    let sp = unsafe: ptr[simd[double, 2]]<-p
+    sp.store(value)
+
+public function store_unaligned_double2(p: ptr[double], value: simd[double, 2]) -> void:
+    store_aligned_double2(p, value)
+
+public function horizontal_sum_double2(v: simd[double, 2]) -> double:
+    return v[0] + v[1]
+
+public function dot_double2(a: simd[double, 2], b: simd[double, 2]) -> double:
+    return horizontal_sum_double2(a * b)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -489,6 +489,7 @@ files:
 - std/http.mt
 - std/http/server.mt
 - std/intern.mt
+- std/iter.mt
 - std/jobs.mt
 - std/json.mt
 - std/libc.mt
@@ -505,6 +506,7 @@ files:
 - std/mem/endian.mt
 - std/mem/heap.mt
 - std/mem/pool.mt
+- std/mem/ptr.mt
 - std/mem/stack.mt
 - std/mem/tracking.mt
 - std/miniaudio.mt
@@ -552,6 +554,7 @@ files:
 - std/sdl3/runtime.mt
 - std/serialize.mt
 - std/set.mt
+- std/simd.mt
 - std/sparse_set.mt
 - std/spatial.mt
 - std/sqlite3.mt
@@ -586,7 +589,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.3.1 installed!
+  Milk Tea 0.3.2 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH