mt-lang 0.4.23 → 0.4.25

data/std/noise.mt

@@ -51,8 +51,8 @@ function perlin2d_impl(perm: array[ubyte, 512], x: float, y: float) -> float:
     let iy = int<-y
     let X = ix & 255
     let Y = iy & 255
-    let xf = x - float<-(ix - (ix & ~255))
-    let yf = y - float<-(iy - (iy & ~255))
+    let xf = x - ix - (ix & ~255)
+    let yf = y - iy - (iy & ~255)
 
     let u = fade(if xf < 0.0: xf + 1.0 else: xf)
     let v = fade(if yf < 0.0: yf + 1.0 else: yf)
@@ -77,9 +77,9 @@ function perlin3d_impl(perm: array[ubyte, 512], x: float, y: float, z: float) ->
     let X = ix & 255
     let Y = iy & 255
     let Z = iz & 255
-    let xf = x - float<-(ix - (ix & ~255))
-    let yf = y - float<-(iy - (iy & ~255))
-    let zf = z - float<-(iz - (iz & ~255))
+    let xf = x - ix - (ix & ~255)
+    let yf = y - iy - (iy & ~255)
+    let zf = z - iz - (iz & ~255)
 
     let u = fade(if xf < 0.0: xf + 1.0 else: xf)
     let v = fade(if yf < 0.0: yf + 1.0 else: yf)
@@ -97,7 +97,11 @@ function perlin3d_impl(perm: array[ubyte, 512], x: float, y: float, z: float) ->
     let y1 = lerp(x1, x2, v)
 
     let x3 = lerp(grad3d(int<-perm[AA + 1], xf, yf, zf - 1.0), grad3d(int<-perm[BA + 1], xf - 1.0, yf, zf - 1.0), u)
-    let x4 = lerp(grad3d(int<-perm[AB + 1], xf, yf - 1.0, zf - 1.0), grad3d(int<-perm[BB + 1], xf - 1.0, yf - 1.0, zf - 1.0), u)
+    let x4 = lerp(
+        grad3d(int<-perm[AB + 1], xf, yf - 1.0, zf - 1.0),
+        grad3d(int<-perm[BB + 1], xf - 1.0, yf - 1.0, zf - 1.0),
+        u
+    )
     let y2 = lerp(x3, x4, v)
 
     return lerp(y1, y2, w)
@@ -107,7 +111,7 @@ function perlin3d_impl(perm: array[ubyte, 512], x: float, y: float, z: float) ->
 
 function floor_f(x: float) -> int:
     let i = int<-x
-    if x < 0.0 and float<-i != x:
+    if x < 0.0 and i != x:
         return i - 1
     return i
 

data/std/ordered_map.mt

@@ -368,10 +368,7 @@ extending OrderedMap[K, V]:
         else:
             unsafe:
                 let parent_ptr = ptr[Node[K, V]]<-parent
-                if location.compare < 0:
-                    read(parent_ptr).left = node
-                else:
-                    read(parent_ptr).right = node
+                if location.compare < 0: read(parent_ptr).left = node else: read(parent_ptr).right = node
 
         this.len += 1
         OrderedMap[K, V].rebalance(this, parent)
@@ -404,10 +401,7 @@ extending OrderedMap[K, V]:
         else:
             unsafe:
                 let parent_ptr = ptr[Node[K, V]]<-parent
-                if location.compare < 0:
-                    read(parent_ptr).left = node
-                else:
-                    read(parent_ptr).right = node
+                if location.compare < 0: read(parent_ptr).left = node else: read(parent_ptr).right = node
 
         this.len += 1
         OrderedMap[K, V].rebalance(this, parent)

data/std/ordered_set.mt

@@ -50,7 +50,8 @@ extending OrderedSet[T]:
             return 0
 
         unsafe:
-            return OrderedSet[T].height(read(ptr[Node[T]]<-node).left) - OrderedSet[T].height(read(ptr[Node[T]]<-node).right)
+            return OrderedSet[T].height(read(ptr[Node[T]]<-node).left) -
+                OrderedSet[T].height(read(ptr[Node[T]]<-node).right)
 
 
     static function minimum(node: ptr[Node[T]]?) -> ptr[Node[T]]?:
@@ -309,10 +310,7 @@ extending OrderedSet[T]:
         else:
             unsafe:
                 let parent_ptr = ptr[Node[T]]<-parent
-                if location.compare < 0:
-                    read(parent_ptr).left = node
-                else:
-                    read(parent_ptr).right = node
+                if location.compare < 0: read(parent_ptr).left = node else: read(parent_ptr).right = node
 
         this.len += 1
         OrderedSet[T].rebalance(this, parent)

data/std/path.mt

@@ -17,10 +17,7 @@ public function normalize_separators(path: str) -> string.String:
     var index: ptr_uint = 0
     while index < path.len:
         let value = path.byte_at(index)
-        if value == 92:
-            result.push_byte(47)
-        else:
-            result.push_byte(value)
+        if value == 92: result.push_byte(47) else: result.push_byte(value)
         index += 1
 
     return result

data/std/process.mt

@@ -89,23 +89,12 @@ public function parent_environment() -> vec.Vec[EnvironmentEntry]:
             if eq_pos == 0 or eq_pos >= len:
                 i += 1
                 continue
-            var nname = string.String.create()
-            nname.reserve(eq_pos)
-            var ni: ptr_uint = 0
-            while ni < eq_pos:
-                nname.push_byte(ubyte<-read(entry_cstr + ni))
-                ni += 1
-            var nvalue = string.String.create()
             let vlen = len - eq_pos - 1
-            if vlen > 0:
-                nvalue.reserve(vlen)
-                var vi: ptr_uint = 0
-                while vi < vlen:
-                    nvalue.push_byte(ubyte<-read(entry_cstr + eq_pos + 1 + vi))
-                    vi += 1
+            let name_view = unsafe: str(data = entry_cstr, len = eq_pos)
+            let value_view = unsafe: str(data = entry_cstr + eq_pos + 1, len = vlen)
             result.push(EnvironmentEntry(
-                name = nname.as_str(),
-                value = nvalue.as_str()
+                name = name_view,
+                value = value_view
             ))
             i += 1
     return result
@@ -263,7 +252,7 @@ function prepare_command(
     let allocated_args = storage.alloc[ptr[char]](command.len + 1) else:
         fatal(c"process args storage exhausted")
 
-    let args_ptr = unsafe: allocated_args
+    let args_ptr = allocated_args
 
     var env_ptr: ptr[ptr[char]]? = null
     var env_storage: ptr[ptr[char]]? = null
@@ -271,7 +260,7 @@ function prepare_command(
         let allocated = storage.alloc[ptr[char]](env.len + 1) else:
             fatal(c"process env pointer storage exhausted")
 
-        let allocated_ptr = unsafe: allocated
+        let allocated_ptr = allocated
         env_ptr = allocated_ptr
         env_storage = allocated_ptr
 
@@ -287,7 +276,7 @@ function prepare_command(
         let allocated_ptr = env_storage else:
             fatal(c"process env pointer storage missing")
 
-        let env_storage_ptr = unsafe: allocated_ptr
+        let env_storage_ptr = allocated_ptr
         index = 0
         while index < env.len:
             let entry = unsafe: read(env.data + index)

data/std/random.mt

@@ -43,12 +43,12 @@ extending Rng:
 
     public editable function next_double() -> double:
         let val = this.next_uint()
-        return double<-val / 4294967296.0
+        return val / 4294967296.0
 
 
     public editable function next_float() -> float:
         let val = this.next_uint()
-        return float<-val / 4294967296.0
+        return val / 4294967296.0
 
 
     public editable function next_ubyte() -> ubyte:

data/std/sdl3/runtime.mt

@@ -9,7 +9,7 @@ function run_app_no_args_uninitialized() -> int:
 var run_app_no_args_slot: array[fn() -> int, 1] = array[fn() -> int, 1](run_app_no_args_uninitialized)
 
 
-function run_app_no_args_trampoline(argc: int, argv: ptr[ptr[char]]) -> int:
+function run_app_no_args_trampoline(_argc: int, _argv: ptr[ptr[char]]) -> int:
     let callback = run_app_no_args_slot[0]
     return callback()
 

data/std/steering.mt

@@ -44,7 +44,13 @@ extending vec2:
         return desired_vel - velocity
 
 
-    public static function arrive(position: vec2, velocity: vec2, target: vec2, max_speed: float, slowing_distance: float) -> vec2:
+    public static function arrive(
+        position: vec2,
+        velocity: vec2,
+        target: vec2,
+        max_speed: float,
+        slowing_distance: float
+    ) -> vec2:
         let offset = target - position
         let distance = offset.length()
         if distance < 0.001:
@@ -54,7 +60,13 @@ extending vec2:
         return desired_vel - velocity
 
 
-    public static function pursuit(position: vec2, velocity: vec2, target_pos: vec2, target_vel: vec2, max_speed: float) -> vec2:
+    public static function pursuit(
+        position: vec2,
+        velocity: vec2,
+        target_pos: vec2,
+        target_vel: vec2,
+        max_speed: float
+    ) -> vec2:
         let offset = target_pos - position
         let distance = offset.length()
         let my_speed = velocity.length()
@@ -65,7 +77,13 @@ extending vec2:
         return vec2.seek(position, velocity, future, max_speed)
 
 
-    public static function evade(position: vec2, velocity: vec2, threat_pos: vec2, threat_vel: vec2, max_speed: float) -> vec2:
+    public static function evade(
+        position: vec2,
+        velocity: vec2,
+        threat_pos: vec2,
+        threat_vel: vec2,
+        max_speed: float
+    ) -> vec2:
         let offset = threat_pos - position
         let distance = offset.length()
         let my_speed = velocity.length()
@@ -76,7 +94,12 @@ extending vec2:
         return vec2.flee(position, velocity, future, max_speed)
 
 
-    public static function wander(velocity: vec2, wander_angle: float, wander_distance: float, wander_radius: float) -> vec2:
+    public static function wander(
+        velocity: vec2,
+        wander_angle: float,
+        wander_distance: float,
+        wander_radius: float
+    ) -> vec2:
         if velocity.length() < 0.001:
             return zero[vec2]
         let forward = set_magnitude(velocity, 1.0)

data/std/string.mt

@@ -121,10 +121,7 @@ extending String:
             new_capacity = 4
 
         while new_capacity < min_capacity:
-            if new_capacity > heap.ptr_uint_max / 2:
-                new_capacity = min_capacity
-            else:
-                new_capacity *= 2
+            if new_capacity > heap.ptr_uint_max / 2: new_capacity = min_capacity else: new_capacity *= 2
 
         let resized = heap.resize[ubyte](this.data, new_capacity) else:
             fatal(c"string.reserve out of memory")

data/std/tar.mt

@@ -119,10 +119,7 @@ function sort_string_values(values: ref[vec.Vec[string.String]]) -> void:
             var should_swap = false
             unsafe:
                 should_swap = compare_text(read(previous_ptr).as_str(), read(current_ptr).as_str()) > 0
-            if should_swap:
-                values.swap(current - 1, current)
-            else:
-                break
+            if should_swap: values.swap(current - 1, current) else: break
 
             current -= 1
 
@@ -318,10 +315,7 @@ function append_header(
         header[checksum_index] = space_byte
         checksum_index += 1
 
-    if kind == EntryKind.directory:
-        header[156] = directory_type_flag
-    else:
-        header[156] = file_type_flag
+    if kind == EntryKind.directory: header[156] = directory_type_flag else: header[156] = file_type_flag
 
     header[257] = 117
     header[258] = 115
@@ -592,7 +586,9 @@ function checked_destination_path(destination_root: str, relative_path: str) ->
             var normalized = payload.value
             defer: normalized.release()
             let normalized_path = normalized.as_str()
-            let escapes_parent = normalized_path.len == 2 and normalized_path.byte_at(0) == 46 and normalized_path.byte_at(1) == 46
+            let escapes_parent = normalized_path.len == 2 and
+                normalized_path.byte_at(0) == 46 and
+                normalized_path.byte_at(1) == 46
             if escapes_parent or normalized_path.starts_with("../"):
                 destination_path.release()
                 return Result[
@@ -626,7 +622,9 @@ public function archive_directory(
     if archive_root_name.len != 0 and path_ops.is_absolute(archive_root_name):
         return Result[bytes.Bytes, Error].failure(error = error_message("tar archive root name must be relative"))
 
-    var output = vec.Vec[ubyte].create()
+    # Consumed by take_vec_bytes below; the flow heuristic cannot see
+    # through the loop above.
+    var output = vec.Vec[ubyte].create()  # lint: ignore(owning-release-leak)
     match append_directory_tree(root_path, archive_root_name, include_hidden, ref_of(output)):
         Result.failure as payload:
             output.release()

data/std/terminal.mt

@@ -288,9 +288,8 @@ function read_stdin(timeout_ms: int) -> Result[vec.Vec[ubyte], Error]:
 
     var result = vec.Vec[ubyte].with_capacity(read_count)
     if read_count != 0:
-        unsafe:
-            let read_span = span[ubyte](data = ptr_of(buffer[0]), len = read_count)
-            result.append_span(read_span)
+        let read_span = span[ubyte](data = ptr_of(buffer[0]), len = read_count)
+        result.append_span(read_span)
 
     return Result[vec.Vec[ubyte], Error].success(value= result)
 
@@ -324,10 +323,9 @@ function apply_modifier(key: ref[KeyEvent], modifier: int) -> void:
         return
 
     let modifier_bits = modifier - 1
-    unsafe:
-        read(key).shifted = (modifier_bits & 1) != 0
-        read(key).alt = (modifier_bits & 2) != 0
-        read(key).ctrl = (modifier_bits & 4) != 0
+    read(key).shifted = (modifier_bits & 1) != 0
+    read(key).alt = (modifier_bits & 2) != 0
+    read(key).ctrl = (modifier_bits & 4) != 0
 
 
 function get_byte(buffer: vec.Vec[ubyte], index: ptr_uint) -> Option[ubyte]:
@@ -402,35 +400,24 @@ function parse_ss3_event(buffer: ref[vec.Vec[ubyte]]) -> Option[Event]:
     match get_ref_byte(buffer, 2):
         Option.some as payload:
             consume_bytes(buffer, 3)
-            match payload.value:
-                80:
-                    return Option[Event].some(value = key_event(KeyCode.function_1, 0, false, false, false, false))
-                81:
-                    return Option[Event].some(value = key_event(KeyCode.function_2, 0, false, false, false, false))
-                82:
-                    return Option[Event].some(value = key_event(KeyCode.function_3, 0, false, false, false, false))
-                83:
-                    return Option[Event].some(value = key_event(KeyCode.function_4, 0, false, false, false, false))
-                72:
-                    return Option[Event].some(value = key_event(KeyCode.home, 0, false, false, false, false))
-                70:
-                    return Option[Event].some(value = key_event(KeyCode.end, 0, false, false, false, false))
-                _:
-                    return Option[Event].some(value = key_event(KeyCode.unknown, 0, false, false, false, false))
+            return match payload.value:
+                80: Option[Event].some(value = key_event(KeyCode.function_1, 0, false, false, false, false))
+                81: Option[Event].some(value = key_event(KeyCode.function_2, 0, false, false, false, false))
+                82: Option[Event].some(value = key_event(KeyCode.function_3, 0, false, false, false, false))
+                83: Option[Event].some(value = key_event(KeyCode.function_4, 0, false, false, false, false))
+                72: Option[Event].some(value = key_event(KeyCode.home, 0, false, false, false, false))
+                70: Option[Event].some(value = key_event(KeyCode.end, 0, false, false, false, false))
+                _: Option[Event].some(value = key_event(KeyCode.unknown, 0, false, false, false, false))
         Option.none:
             return Option[Event].none
 
 
 function decode_mouse_button(code: int) -> MouseButton:
-    match code & 3:
-        0:
-            return MouseButton.left
-        1:
-            return MouseButton.middle
-        2:
-            return MouseButton.right
-        _:
-            return MouseButton.none
+    return match code & 3:
+        0: MouseButton.left
+        1: MouseButton.middle
+        2: MouseButton.right
+        _: MouseButton.none
 
 
 function parse_mouse_event(buffer: ref[vec.Vec[ubyte]]) -> Option[Event]:
@@ -534,7 +521,7 @@ function parse_mouse_event(buffer: ref[vec.Vec[ubyte]]) -> Option[Event]:
             return Option[Event].none
 
 
-function parse_csi_letter(buffer: ref[vec.Vec[ubyte]], final_byte: ubyte, modifier: int) -> Event:
+function parse_csi_letter(_buffer: ref[vec.Vec[ubyte]], final_byte: ubyte, modifier: int) -> Event:
     var event_ = key_event(KeyCode.unknown, 0, false, false, false, false)
     if final_byte == 65:
         event_ = key_event(KeyCode.up, 0, false, false, false, false)
@@ -812,20 +799,14 @@ public function set_rgb_background(red: int, green: int, blue: int) -> Result[bo
 public function set_bold(enabled: bool) -> Result[bool, Error]:
     var sequence = string.String.with_capacity(6)
     defer: sequence.release()
-    if enabled:
-        append_csi(ref_of(sequence), "1m")
-    else:
-        append_csi(ref_of(sequence), "22m")
+    if enabled: append_csi(ref_of(sequence), "1m") else: append_csi(ref_of(sequence), "22m")
     return write_stdout_sequence(sequence, "terminal bold styling failed")
 
 
 public function set_underline(enabled: bool) -> Result[bool, Error]:
     var sequence = string.String.with_capacity(6)
     defer: sequence.release()
-    if enabled:
-        append_csi(ref_of(sequence), "4m")
-    else:
-        append_csi(ref_of(sequence), "24m")
+    if enabled: append_csi(ref_of(sequence), "4m") else: append_csi(ref_of(sequence), "24m")
     return write_stdout_sequence(sequence, "terminal underline styling failed")
 
 

data/std/thread.mt

@@ -49,9 +49,8 @@ function thread_entry_void(frame: ptr[void]) -> void:
 public function spawn_raw(entry: fn(arg: ptr[void]) -> void, arg: ptr[void]) -> Result[Thread, Error]:
     let handle = heap.must_alloc_zeroed[NativeThreadHandle](1)
     let state = heap.must_alloc_zeroed[RawStartState](1)
-    unsafe:
-        state.entry = entry
-        state.arg = arg
+    state.entry = entry
+    state.arg = arg
 
     let status_code = libuv.thread_create(handle, thread_entry_raw, unsafe: ptr[void]<-state)
     if status_code != 0:
@@ -65,7 +64,7 @@ public function spawn_raw(entry: fn(arg: ptr[void]) -> void, arg: ptr[void]) ->
 public function spawn(run: fn() -> void) -> Result[Thread, Error]:
     let handle = heap.must_alloc_zeroed[NativeThreadHandle](1)
     let state = heap.must_alloc_zeroed[VoidStartState](1)
-    unsafe: state.run = run
+    state.run = run
 
     let status_code = libuv.thread_create(handle, thread_entry_void, unsafe: ptr[void]<-state)
     if status_code != 0:

data/std/tls.mt

@@ -115,8 +115,8 @@ function handle_as_poll(handle: ptr[NativeHandle]) -> ptr[NativePollHandle]:
     return unsafe: ptr[NativePollHandle]<-handle
 
 
-function noop_waiter(frame: ptr[void]) -> void:
-    unsafe: frame
+function noop_waiter(_frame: ptr[void]) -> void:
+    pass
 
 
 function poll_task(state: ptr[PollState]) -> Task[Result[int, Error]]:
@@ -271,19 +271,18 @@ function poll_on(runtime: aio.Runtime, fd: int, events: int) -> Task[Result[int,
     let state = heap.must_alloc_zeroed[PollState](1)
     let poll = alloc_poll_handle()
 
-    unsafe:
-        state.ready = false
-        state.status_code = 0
-        state.revents = 0
-        state.error = empty_error()
-        state.error_owned = false
-        state.waiter_frame = null
-        state.waiter = noop_waiter
-        state.waiter_registered = false
-        state.handle = poll
-        state.closing = false
-        state.closed = false
-        state.released = false
+    state.ready = false
+    state.status_code = 0
+    state.revents = 0
+    state.error = empty_error()
+    state.error_owned = false
+    state.waiter_frame = null
+    state.waiter = noop_waiter
+    state.waiter_registered = false
+    state.handle = poll
+    state.closing = false
+    state.closed = false
+    state.released = false
 
     let init_status = libuv.poll_init(loop, poll, fd)
     if init_status != 0:
@@ -416,7 +415,7 @@ async function read_once_on(
     let buffer = heap.must_alloc[ubyte](max_bytes)
     while true:
         let client = unsafe: read(state).client else:
-            unsafe: heap.release(buffer)
+            heap.release(buffer)
             return Result[bytes.Bytes, Error].failure(error = tls_error("tls stream is released"))
 
         var transferred: ptr_uint = 0
@@ -481,10 +480,8 @@ public async function connect_on(runtime: aio.Runtime, host: str, port: int) ->
             defer: release_socket_addresses(ref_of(addresses))
 
             var last_error = tls_error("tls connect failed")
-            var last_error_owned = true
             defer:
-                if last_error_owned:
-                    last_error.release()
+                last_error.release()
 
             var index: ptr_uint = 0
             while index < addresses.len:
@@ -494,13 +491,10 @@ public async function connect_on(runtime: aio.Runtime, host: str, port: int) ->
                 let connect_result = await net.connect_on(runtime, unsafe: read(current))
                 match connect_result:
                     Result.failure as connect_error_payload:
-                        if last_error_owned:
-                            last_error.release()
+                        last_error.release()
                         last_error = take_net_error(connect_error_payload.error)
-                        last_error_owned = true
                     Result.success as connect_payload:
-                        if last_error_owned:
-                            last_error.release()
+                        last_error.release()
                         return await client_on(runtime, host, connect_payload.value)
 
                 index += 1
@@ -536,11 +530,10 @@ public async function client_on(runtime: aio.Runtime, host: str, transport: net.
                 return Result[Stream, Error].failure(error = tls_error("tls connect failed"))
 
             let state = heap.must_alloc_zeroed[StreamState](1)
-            unsafe:
-                state.client = live_client
-                state.tcp = owned_transport
-                state.fd = payload.value
-                state.pending_operation = false
+            state.client = live_client
+            state.tcp = owned_transport
+            state.fd = payload.value
+            state.pending_operation = false
 
             var stream = Stream(state = state)
             let handshake_result = await handshake_on(runtime, state)