mt-lang 0.3.1 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e212444d219545cf86e5711bdcd0eb02028b94fd8b0ae1ac8b6ade08b25967da
-  data.tar.gz: fce0d6413dfc434af53103228604527bf9f08fef30dcbd7013fd50f5bd30878b
+  metadata.gz: 7cd20acdc903389647adc4c6c7e552fdbbf35694f69328b0427134109782b21f
+  data.tar.gz: 5cc1498f88f6ddb87eaa2d7a7da9f54c76a6ee9a38fe3e33f68ddc6120160057
 SHA512:
-  metadata.gz: acc176d3ad35b7184b3df7e4beb4fb6a411bcf613bc7905fa16f215388d0ff26a6a0cea201f124f861f571efa7166098e969cffbe5e600ccf2e30614c5351065
-  data.tar.gz: 7664d2ceb6235804d8ee78e6dd594ece82492f2e1d00c792762c696d122e3ad669b57dd4825acbada2c5d83dcb1fddef0b366dacd2f363d475bbedefba6122a9
+  metadata.gz: bcf70e8639131a5d7198028d7f70e632ebb817eba816635d24d753dfa4023bc0364e0b8a6082f2ccd747d40bf7c5f7d778ad2efeb2b6283e6c10604a4f44492b
+  data.tar.gz: b802f4c8cc2654c8464ec156967430573577a76316d916e31e5b043d81a61a8e2279bf5fadc037b38f2f388e3241507b4f17be08b78558fa2424da4b72315c31

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/lsp/diagnostics.rb

@@ -211,7 +211,7 @@ module MilkTea
         unresolved_import_paths.include?(import_path)
       end
 
-    def self.path_to_uri(path)
+      def self.path_to_uri(path)
         escaped_path = path.split('/').map { |seg| CGI.escape(seg).gsub('+', '%20') }.join('/')
         "file://#{escaped_path}"
       end

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

@@ -605,10 +605,13 @@ module MilkTea
       end
 
       def collect_method_provider_import_uses(receiver, member_name, used, binding_resolution)
-        return unless receiver.is_a?(AST::Identifier)
         return unless @sema_facts.respond_to?(:imports)
 
-        receiver_type = identifier_binding_type(receiver, binding_resolution)
+        receiver_type = if receiver.is_a?(AST::Identifier)
+          identifier_binding_type(receiver, binding_resolution)
+        else
+          resolved_expr_type(receiver)
+        end
         return unless receiver_type
 
         @sema_facts.imports.each do |local_name, module_binding|
@@ -619,6 +622,14 @@ module MilkTea
         end
       end
 
+      def resolved_expr_type(expr)
+        return nil unless @sema_facts.respond_to?(:ast) && @sema_facts.ast.respond_to?(:node_ids)
+        return nil unless @sema_facts.respond_to?(:resolved_expr_types)
+
+        node_id = @sema_facts.ast.node_ids[expr.object_id]
+        node_id ? @sema_facts.resolved_expr_types[node_id] : nil
+      end
+
       def identifier_binding_type(identifier, binding_resolution)
         binding_id = binding_resolution.identifier_binding_ids[identifier.object_id]
         return nil unless binding_id
@@ -653,7 +664,7 @@ module MilkTea
           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("__lint_receiver_arg#{index}")
+              argument.is_a?(Types::LiteralTypeArg) ? argument : Types::TypeVar.new("__receiver_arg#{index}")
             end,
           )
         when Types::StructInstance

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/blackboard.mt

@@ -0,0 +1,100 @@
+## Blackboard — typed key-value shared state for AI.
+##
+## Store and retrieve named values that multiple AI systems
+## can read and write. Linear O(n) lookup (tuned for small
+## sizes — typical AI blackboards have under 20 entries).
+##
+##   import std.blackboard as bb
+##   var board = bb.Blackboard[float].create()
+##   board.set("health", 100.0)
+##   let h = board.get("health") else: 0.0
+
+import std.vec as vec
+
+
+public struct BlackboardEntry[T]:
+    key: str
+    value: T
+
+
+public struct Blackboard[T]:
+    entries: vec.Vec[BlackboardEntry[T]]
+
+
+# ── internal helpers ──
+
+function find_entry[T](board: ref[Blackboard[T]], key: str) -> ptr[BlackboardEntry[T]]?:
+    for entry in board.entries:
+        unsafe:
+            if read(entry).key == key:
+                return entry
+    return null
+
+
+# ── public API ──
+
+extending Blackboard[T]:
+    public static function create() -> Blackboard[T]:
+        return Blackboard[T](
+            entries = vec.Vec[BlackboardEntry[T]].create()
+        )
+
+
+    public editable function set(key: str, value: T) -> void:
+        let existing = find_entry(ref_of(this), key)
+        if existing != null:
+            unsafe:
+                read(ptr[BlackboardEntry[T]]<-existing).value = value
+            return
+        this.entries.push(BlackboardEntry[T](key = key, value = value))
+
+
+    public function get(key: str) -> Option[T]:
+        var n = this.entries.len()
+        var i: ptr_uint = 0
+        while i < n:
+            let entry_ptr = this.entries.get(i) else:
+                break
+            unsafe:
+                if read(entry_ptr).key == key:
+                    return Option[T].some(value = read(entry_ptr).value)
+            i += 1
+        return Option[T].none
+
+
+    public function has(key: str) -> bool:
+        var n = this.entries.len()
+        var i: ptr_uint = 0
+        while i < n:
+            let entry_ptr = this.entries.get(i) else:
+                break
+            unsafe:
+                if read(entry_ptr).key == key:
+                    return true
+            i += 1
+        return false
+
+
+    public editable function remove(key: str) -> void:
+        var n = this.entries.len()
+        var i: ptr_uint = 0
+        while i < n:
+            let entry_ptr = this.entries.get(i) else:
+                break
+            unsafe:
+                if read(entry_ptr).key == key:
+                    this.entries.swap_remove(i)
+                    return
+            i += 1
+
+
+    public editable function clear() -> void:
+        this.entries.clear()
+
+
+    public function count() -> ptr_uint:
+        return this.entries.len()
+
+
+    public editable function release() -> void:
+        this.entries.release()

data/std/cmd.mt

@@ -0,0 +1,132 @@
+## Command pattern — undo/redo with paired do/undo callbacks.
+##
+## Encapsulate reversible actions as value-objects. Stack-based
+## history for linear undo/redo. Recording for replay capture.
+##
+##   import std.cmd as cmd
+##   var hist = cmd.History[Editor].create()
+##   hist.execute(cmd.Cmd[Editor].create(ctx, do_insert, undo_delete))
+##   hist.undo()
+
+import std.vec as vec
+
+
+public struct Cmd[Context]:
+    context: ptr[Context]
+    do_fn: fn(context: ptr[Context]) -> void
+    undo_fn: fn(context: ptr[Context]) -> void
+
+
+public struct History[Context]:
+    undos: vec.Vec[Cmd[Context]]
+    redos: vec.Vec[Cmd[Context]]
+
+
+public struct Recording[Context]:
+    cmds: vec.Vec[Cmd[Context]]
+
+
+# ── Cmd ──
+
+extending Cmd[Context]:
+    public static function create(
+        context: ptr[Context],
+        do_fn: fn(context: ptr[Context]) -> void,
+        undo_fn: fn(context: ptr[Context]) -> void
+    ) -> Cmd[Context]:
+        return Cmd[Context](context = context, do_fn = do_fn, undo_fn = undo_fn)
+
+
+    public function invoke() -> void:
+        this.do_fn(this.context)
+
+
+    public function revert() -> void:
+        this.undo_fn(this.context)
+
+
+# ── History ──
+
+extending History[Context]:
+    public static function create() -> History[Context]:
+        return History[Context](
+            undos = vec.Vec[Cmd[Context]].create(),
+            redos = vec.Vec[Cmd[Context]].create()
+        )
+
+
+    public editable function execute(cmd: Cmd[Context]) -> void:
+        cmd.invoke()
+        this.undos.push(cmd)
+        this.redos.clear()
+
+
+    public editable function undo() -> bool:
+        let cmd = this.undos.pop() else:
+            return false
+        cmd.revert()
+        this.redos.push(cmd)
+        return true
+
+
+    public editable function redo() -> bool:
+        let cmd = this.redos.pop() else:
+            return false
+        cmd.invoke()
+        this.undos.push(cmd)
+        return true
+
+
+    public function can_undo() -> bool:
+        return this.undos.len() > 0
+
+
+    public function can_redo() -> bool:
+        return this.redos.len() > 0
+
+
+    public function undo_count() -> ptr_uint:
+        return this.undos.len()
+
+
+    public function redo_count() -> ptr_uint:
+        return this.redos.len()
+
+
+    public editable function clear() -> void:
+        this.undos.clear()
+        this.redos.clear()
+
+
+    public editable function release() -> void:
+        this.undos.release()
+        this.redos.release()
+
+
+# ── Recording ──
+
+extending Recording[Context]:
+    public static function create() -> Recording[Context]:
+        return Recording[Context](cmds = vec.Vec[Cmd[Context]].create())
+
+
+    public editable function record(cmd: Cmd[Context]) -> void:
+        this.cmds.push(cmd)
+
+
+    public editable function replay(history: ref[History[Context]]) -> void:
+        for entry in this.cmds:
+            unsafe:
+                history.execute(read(entry))
+
+
+    public function count() -> ptr_uint:
+        return this.cmds.len()
+
+
+    public editable function clear() -> void:
+        this.cmds.clear()
+
+
+    public editable function release() -> void:
+        this.cmds.release()

data/std/color.mt

@@ -0,0 +1,245 @@
+## Color utilities — RGBA conversion, blending, and presets.
+##
+## Provides an RGBA Color struct compatible with raylib/FBO
+## layouts, plus HSL/HSV conversion, hex parsing, alpha
+## blending, and common named-color constants.
+##
+##   import std.color as clr
+##   let c = clr.Color.from_hsl(210.0, 0.8, 0.6)
+##   let blended = c.alpha_blend(clr.WHITE)
+
+public struct Color:
+    r: ubyte
+    g: ubyte
+    b: ubyte
+    a: ubyte
+
+
+public const WHITE:  Color = Color(r = 255, g = 255, b = 255, a = 255)
+public const BLACK:  Color = Color(r = 0,   g = 0,   b = 0,   a = 255)
+public const RED:    Color = Color(r = 255, g = 0,   b = 0,   a = 255)
+public const GREEN:  Color = Color(r = 0,   g = 255, b = 0,   a = 255)
+public const BLUE:   Color = Color(r = 0,   g = 0,   b = 255, a = 255)
+public const YELLOW: Color = Color(r = 255, g = 255, b = 0,   a = 255)
+public const CYAN:   Color = Color(r = 0,   g = 255, b = 255, a = 255)
+public const MAGENTA:Color = Color(r = 255, g = 0,   b = 255, a = 255)
+public const GRAY:   Color = Color(r = 128, g = 128, b = 128, a = 255)
+public const ORANGE: Color = Color(r = 255, g = 165, b = 0,   a = 255)
+public const PINK:   Color = Color(r = 255, g = 192, b = 203, a = 255)
+public const PURPLE: Color = Color(r = 128, g = 0,   b = 128, a = 255)
+public const TRANSPARENT: Color = Color(r = 0, g = 0, b = 0, a = 0)
+
+
+# ── math helpers ──
+
+function fmin(a: float, b: float) -> float:
+    if a < b: return a
+    return b
+
+
+function fmax(a: float, b: float) -> float:
+    if a > b: return a
+    return b
+
+
+function fabs(x: float) -> float:
+    if x < 0.0: return -x
+    return x
+
+
+function fmod(x: float, m: float) -> float:
+    # x - floor(x / m) * m
+    let div = x / m
+    let fl = float<-(int<-(div))
+    if div < 0.0 and float<-(int<-(div)) != div:
+        return x - (fl - 1.0) * m
+    return x - fl * m
+
+
+# ── public API ──
+
+extending Color:
+    public static function from_rgba(r: ubyte, g: ubyte, b: ubyte, a: ubyte) -> Color:
+        return Color(r = r, g = g, b = b, a = a)
+
+
+    public static function from_hsl(h: float, s: float, l: float) -> Color:
+        # h: 0..360, s: 0..1, l: 0..1
+        var hh = fmod(h, 360.0)
+        if hh < 0.0: hh = hh + 360.0
+
+        let c = (1.0 - fabs(2.0 * l - 1.0)) * s
+        let x = c * (1.0 - fabs(fmod(hh / 60.0, 2.0) - 1.0))
+        let m = l - c / 2.0
+
+        var r1: float = 0.0
+        var g1: float = 0.0
+        var b1: float = 0.0
+
+        if hh < 60.0:
+            r1 = c
+            g1 = x
+        else if hh < 120.0:
+            r1 = x
+            g1 = c
+        else if hh < 180.0:
+            g1 = c
+            b1 = x
+        else if hh < 240.0:
+            g1 = x
+            b1 = c
+        else if hh < 300.0:
+            r1 = x
+            b1 = c
+        else:
+            r1 = c
+            b1 = x
+
+        return Color(
+            r = ubyte<-((r1 + m) * 255.0),
+            g = ubyte<-((g1 + m) * 255.0),
+            b = ubyte<-((b1 + m) * 255.0),
+            a = 255
+        )
+
+
+    public static function from_hsv(h: float, s: float, v: float) -> Color:
+        var hh = fmod(h, 360.0)
+        if hh < 0.0: hh = hh + 360.0
+
+        let c = v * s
+        let x = c * (1.0 - fabs(fmod(hh / 60.0, 2.0) - 1.0))
+        let m = v - c
+
+        var r1: float = 0.0
+        var g1: float = 0.0
+        var b1: float = 0.0
+
+        if hh < 60.0:
+            r1 = c
+            g1 = x
+        else if hh < 120.0:
+            r1 = x
+            g1 = c
+        else if hh < 180.0:
+            g1 = c
+            b1 = x
+        else if hh < 240.0:
+            g1 = x
+            b1 = c
+        else if hh < 300.0:
+            r1 = x
+            b1 = c
+        else:
+            r1 = c
+            b1 = x
+
+        return Color(
+            r = ubyte<-((r1 + m) * 255.0),
+            g = ubyte<-((g1 + m) * 255.0),
+            b = ubyte<-((b1 + m) * 255.0),
+            a = 255
+        )
+
+
+    public function to_hsl() -> (float, float, float):
+        let rf = float<-(this.r) / 255.0
+        let gf = float<-(this.g) / 255.0
+        let bf = float<-(this.b) / 255.0
+
+        let mx = fmax(fmax(rf, gf), bf)
+        let mn = fmin(fmin(rf, gf), bf)
+        let delta = mx - mn
+
+        let l = (mx + mn) / 2.0
+
+        var h: float = 0.0
+        let s = if delta == 0.0: 0.0 else: delta / (1.0 - fabs(2.0 * l - 1.0))
+
+        if delta != 0.0:
+            if mx == rf:
+                h = fmod((gf - bf) / delta, 6.0)
+            else if mx == gf:
+                h = (bf - rf) / delta + 2.0
+            else:
+                h = (rf - gf) / delta + 4.0
+            h = h * 60.0
+            if h < 0.0:
+                h = h + 360.0
+
+        return (h, s, l)
+
+
+    public function to_hsv() -> (float, float, float):
+        let rf = float<-(this.r) / 255.0
+        let gf = float<-(this.g) / 255.0
+        let bf = float<-(this.b) / 255.0
+
+        let mx = fmax(fmax(rf, gf), bf)
+        let mn = fmin(fmin(rf, gf), bf)
+        let delta = mx - mn
+
+        var h: float = 0.0
+        let s = if mx == 0.0: 0.0 else: delta / mx
+        let v = mx
+
+        if delta != 0.0:
+            if mx == rf:
+                h = fmod((gf - bf) / delta, 6.0)
+            else if mx == gf:
+                h = (bf - rf) / delta + 2.0
+            else:
+                h = (rf - gf) / delta + 4.0
+            h = h * 60.0
+            if h < 0.0:
+                h = h + 360.0
+
+        return (h, s, v)
+
+
+    public function lerp(target: Color, t: float) -> Color:
+        let r = float<-(this.r) + (float<-(target.r) - float<-(this.r)) * t
+        let g = float<-(this.g) + (float<-(target.g) - float<-(this.g)) * t
+        let b = float<-(this.b) + (float<-(target.b) - float<-(this.b)) * t
+        let a = float<-(this.a) + (float<-(target.a) - float<-(this.a)) * t
+        return Color(r = ubyte<-(r), g = ubyte<-(g), b = ubyte<-(b), a = ubyte<-(a))
+
+
+    public function alpha_blend(background: Color) -> Color:
+        if this.a == 0:
+            return background
+        if this.a == 255:
+            return this
+
+        let sa = float<-(this.a) / 255.0
+        let da = float<-(background.a) / 255.0
+
+        let r_out = float<-(this.r) * sa + float<-(background.r) * da * (1.0 - sa)
+        let g_out = float<-(this.g) * sa + float<-(background.g) * da * (1.0 - sa)
+        let b_out = float<-(this.b) * sa + float<-(background.b) * da * (1.0 - sa)
+        let a_out = sa + da * (1.0 - sa)
+
+        return Color(
+            r = ubyte<-(r_out),
+            g = ubyte<-(g_out),
+            b = ubyte<-(b_out),
+            a = ubyte<-(a_out * 255.0)
+        )
+
+
+    public function scale(factor: float) -> Color:
+        let r = fmin(fmax(float<-(this.r) * factor, 0.0), 255.0)
+        let g = fmin(fmax(float<-(this.g) * factor, 0.0), 255.0)
+        let b = fmin(fmax(float<-(this.b) * factor, 0.0), 255.0)
+        return Color(r = ubyte<-(r), g = ubyte<-(g), b = ubyte<-(b), a = this.a)
+
+
+    public function multiply(other: Color) -> Color:
+        let r = ubyte<-(int<-((int<-(this.r) * int<-(other.r)) / 255))
+        let g = ubyte<-(int<-((int<-(this.g) * int<-(other.g)) / 255))
+        let b = ubyte<-(int<-((int<-(this.b) * int<-(other.b)) / 255))
+        return Color(r = r, g = g, b = b, a = this.a)
+
+
+    public function with_alpha(a: ubyte) -> Color:
+        return Color(r = this.r, g = this.g, b = this.b, a = a)