mt-lang 0.4.23 → 0.4.25

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

@@ -366,6 +366,10 @@ module MilkTea
       end
       def check_redundant_unsafe(node)
         return unless @sema_facts
+        # Generic bodies are only fully checked once instantiated elsewhere,
+        # so required-unsafe facts are incomplete for them: an unsafe block in
+        # a generic body may be required by concrete instances.
+        return if generic_function_context?
         return if @sema_facts.required_unsafe_lines.include?(node.line)
 
         @warnings << Warning.new(
@@ -830,43 +834,64 @@ module MilkTea
         )
       end
 
+      # Simulates the actual one-line join: every branch body must be a single
+      # physical line with balanced delimiters, and the composed line must fit
+      # the column budget. Anything that cannot be joined cleanly is reported
+      # as "too wide" so the hint is suppressed.
       def inline_if_too_wide?(statement, stmts)
         return false if statement.branches.empty?
 
-        text = +""
-
-        statement.branches.each_with_index do |b, i|
-          cond_src = source_line_from(b.line, b.column)
-          return false unless cond_src
-
-          stmt_col = stmts[i]&.column
-          stmt_line = stmts[i]&.line
-          body_src = source_line_from(stmt_line, stmt_col)
-          return false unless body_src
-
-          text << cond_src
-          text << " "
-          text << body_src
-          text << " "
-        end
+        if_line_idx = Integer(statement.line) - 1
+        return true if if_line_idx.negative? || if_line_idx >= @source_lines.length
+
+        header = @source_lines[if_line_idx].to_s
+        return true unless header.strip.start_with?("if ")
+
+        indent = header[/\A[ \t]*/].to_s
+        segments = []
+        cur_header = header.strip
+        cur_body = nil
+        idx = if_line_idx + 1
+        while idx < @source_lines.length
+          line = @source_lines[idx].to_s.rstrip
+          break if line.empty?
+
+          line_indent = line[/\A[ \t]*/].to_s
+          if line_indent == indent && (line.strip == "else:" || line.strip.start_with?("else if "))
+            return true if cur_body.nil?
+
+            segments << [cur_header, cur_body]
+            cur_header = line.strip
+            cur_body = nil
+            idx += 1
+            next
+          end
+          break if line_indent.length <= indent.length
+          return true unless cur_body.nil?
 
-        if statement.else_line
-          else_src = source_line_from(statement.else_line, statement.else_column)
-          return false unless else_src
-          text << else_src
-          text << " "
+          cur_body = line.strip
+          idx += 1
         end
+        return true if cur_body.nil?
+        return true unless cur_header.strip == "else:"
 
-        stmt_col = stmts.last&.column
-        stmt_line = stmts.last&.line
-        else_body = source_line_from(stmt_line, stmt_col)
-        return false unless else_body
-        text << else_body
+        segments << [cur_header, cur_body]
+        joined = indent + segments.map { |h, b| "#{h} #{b}" }.join(" ")
+        joined.length > 120 || !balanced_inline_line?(joined)
+      end
 
-        # The inline form would start at the `if` keyword's column, so the real
-        # line width includes the surrounding block's indentation.
-        indent = statement.branches.first.column.to_i - 1
-        (indent + text.strip.length) > 120
+      def balanced_inline_line?(text)
+        depth = 0
+        text.each_char do |ch|
+          case ch
+          when "(", "["
+            depth += 1
+          when ")", "]"
+            depth -= 1
+            return false if depth.negative?
+          end
+        end
+        depth.zero?
       end
 
       def source_line_from(line, column)
@@ -966,7 +991,9 @@ module MilkTea
         struct_type = resolve_expr_type(call)
         return unless struct_type.is_a?(Types::Struct)
         source_type = resolve_expr_type(copied.first.value.receiver)
-        return unless source_type.equal?(struct_type) || (source_type.respond_to?(:name) && source_type.name == struct_type.name)
+        # Compare qualified names: bare names collide across modules
+        # (e.g. net::Config vs chan::Config).
+        return unless source_type.respond_to?(:to_s) && source_type.to_s == struct_type.to_s
 
         field_names = struct_type.fields.keys.map(&:to_s).to_set
         copied_names = copied.map { |arg| arg.name.to_s }.to_set

data/lib/milk_tea/tooling/linter.rb

@@ -77,6 +77,7 @@ module MilkTea
       redundant-else
       redundant-return
       redundant-type-annotation
+      redundant-unsafe
       reserved-primitive-name
       trailing-list-comma
     ].freeze
@@ -96,6 +97,7 @@ module MilkTea
       "redundant-else" => "Remove redundant else",
       "redundant-return" => "Remove redundant return",
       "redundant-type-annotation" => "Remove redundant type annotation",
+      "redundant-unsafe" => "Remove redundant unsafe",
       "prefer-let-else" => "Rewrite as let-else",
       "prefer-var-else" => "Rewrite as var-else",
       "prefer-inline-methods" => "Inline methods into struct",
@@ -358,7 +360,7 @@ module MilkTea
     # redundant-else,
     # redundant-return, reserved-primitive-name,
     # trailing-list-comma.
-    # Returns the fixed source (may be identical if nothing was fixable).
+    # Returns the fixed source (may be identical to nothing-was-fixable input).
     def self.fix_source(source, path: nil, sema_facts: nil, select: nil, ignore: nil, max_passes: 5, profile: nil)
       pass_limit = [max_passes.to_i, 1].max
       current_source = source
@@ -446,6 +448,11 @@ module MilkTea
       working_context = sema_facts ? nil : best_effort_lint_context(source, path:)
       working_sema_facts = sema_facts || working_context[:facts]
       unresolved_import_paths = sema_facts ? Set.new : working_context[:unresolved_import_paths]
+      # With unresolved imports the analysis facts are incomplete (receiver
+      # editability, casts, ownership), so hint rules can misfire and fixes
+      # would land on false positives. Leave such sources to the author.
+      return source if unresolved_import_paths.any?
+
       warnings = lint_source(
         source,
         path:,

data/lib/milk_tea/tooling/std_catalog.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+module MilkTea
+  # Discovers the hand-written standard library modules shipped in std/, and
+  # resolves module names to source paths for tooling commands.
+  #
+  # Generated modules (bindgen output under std/c/ and imported-binding
+  # wrappers such as raylib or zstd) are excluded from discovery but stay
+  # resolvable, so `std show` can still print them.
+  class StdCatalog
+    Entry = Struct.new(:name, :description, :category, :path, keyword_init: true)
+
+    GENERATED_HEADER_PREFIX = "# generated by mtc"
+    PLATFORM_SUFFIXES = %w[linux windows wasm].freeze
+    EXCLUDED_DIRECTORIES = %w[c].freeze
+
+    CATEGORY_ORDER = [
+      "Core & Patterns",
+      "Collections",
+      "Memory",
+      "Text & Formatting",
+      "Math & Simulation",
+      "Data & Serialization",
+      "Concurrency & Time",
+      "Files & System",
+      "Network",
+      "Security",
+      "AI & Behavior",
+      "Game & Graphics",
+    ].freeze
+
+    # name => [category, description]. Must cover every hand-written module
+    # discovered under std/; a test enforces that coverage.
+    REGISTRY = {
+      "asset_pack" => ["Game & Graphics", "MTAP asset pack reader and writer for bundled runtime assets."],
+      "async" => ["Concurrency & Time", "Async/await runtime facade over a pluggable event-loop backend."],
+      "async.libuv_runtime" => ["Concurrency & Time", "libuv-backed async runtime implementation."],
+      "async.mailbox" => ["Concurrency & Time", "Typed mailboxes for message passing between async tasks."],
+      "async.runtime" => ["Concurrency & Time", "Async backend selection and event-loop plumbing shared by async code."],
+      "base64" => ["Text & Formatting", "Base64 encode and decode."],
+      "behavior_tree" => ["AI & Behavior", "Behavior trees with sequence, selector, decorator, and leaf nodes."],
+      "binary" => ["Data & Serialization", "Binary reader/writer with explicit endianness and error reporting."],
+      "binary_heap" => ["Collections", "Binary heap over a flat array with sift-up/sift-down operations."],
+      "bitset" => ["Collections", "Fixed-capacity bit array with set, clear, test, and population count."],
+      "blackboard" => ["AI & Behavior", "Typed key-value shared state for AI agents."],
+      "box" => ["Core & Patterns", "Explicit single-value heap storage for owned boxed values."],
+      "bytes" => ["Data & Serialization", "Byte buffer type with slicing, comparison, and stream I/O."],
+      "cli" => ["Files & System", "Command-line parsing helpers for flags, options, and positionals."],
+      "cmd" => ["Core & Patterns", "Command pattern with paired do/undo callbacks for undo/redo stacks."],
+      "color" => ["Game & Graphics", "RGBA color conversion, blending, and named presets."],
+      "cookie" => ["Data & Serialization", "HTTP cookie parsing and serialization."],
+      "counter" => ["Collections", "Occurrence counter keyed by value, a counting multiset."],
+      "crypto" => ["Security", "Digests, HMAC, and secure random via the platform crypto bindings."],
+      "cstring" => ["Text & Formatting", "Null-terminated C string helpers backed by libc memory routines."],
+      "ctype" => ["Text & Formatting", "Character classification: alnum, digit, space, and case tests."],
+      "curl.runtime" => ["Network", "libcurl runtime glue for handle setup and error reporting."],
+      "deque" => ["Collections", "Double-ended queue with amortized O(1) operations at both ends."],
+      "encoding" => ["Text & Formatting", "UTF-8 validation, codepoint iteration, and encoding helpers."],
+      "env" => ["Files & System", "Environment variable access returning Option values."],
+      "errno" => ["Files & System", "errno code constants and error message lookup."],
+      "fmt" => ["Text & Formatting", "Value formatting helpers for integers, floats, and fixed buffers."],
+      "fs" => ["Files & System", "File and directory operations with platform-specific variants."],
+      "fsm" => ["AI & Behavior", "Finite state machines with table-driven transitions and dispatch."],
+      "goap" => ["AI & Behavior", "Goal-oriented action planning (GOAP) with forward search."],
+      "graph" => ["Game & Graphics", "Weighted graph algorithms such as shortest paths and reachability."],
+      "gzip" => ["Data & Serialization", "Gzip and zlib compression and decompression."],
+      "hash" => ["Core & Patterns", "Canonical hash, equality, and ordering for common primitive types."],
+      "htn" => ["AI & Behavior", "Hierarchical Task Network (HTN) planner."],
+      "http" => ["Network", "HTTP client for requests, responses, and chunked bodies."],
+      "http.server" => ["Network", "Small HTTP server with routing, static files, and JSON responses."],
+      "input" => ["Game & Graphics", "Input action mapping that decouples logical actions from physical devices."],
+      "intern" => ["Text & Formatting", "String interning table producing unique identifier handles."],
+      "iter" => ["Core & Patterns", "Composable lazy iteration adaptors over sequences."],
+      "jobs" => ["Concurrency & Time", "Job scheduler for fan-out parallel work with completion tracking."],
+      "json" => ["Data & Serialization", "JSON parsing and serialization over cjson with arena-backed values."],
+      "libc" => ["Files & System", "Curated libc facade for memory, string, process, and math functions."],
+      "linear_algebra" => ["Math & Simulation", "Vectors and matrices for 2D/3D graphics and physics."],
+      "linked_map" => ["Collections", "Hash map with a doubly-linked order list for O(1) reordering."],
+      "linked_map_view" => ["Collections", "Read-only snapshot views over linked_map instances."],
+      "linked_set" => ["Collections", "Insertion-ordered hash set backed by a linked list."],
+      "log" => ["Files & System", "Leveled logging with configurable output sinks."],
+      "lru_cache" => ["Collections", "Least-recently-used cache with bounded capacity."],
+      "map" => ["Collections", "Chained hash map with pluggable hashing for generic keys and values."],
+      "math" => ["Math & Simulation", "Mathematical constants and functions beyond the language builtins."],
+      "mem.arena" => ["Memory", "Region allocator: bump allocation with O(1) mark/reset."],
+      "mem.endian" => ["Memory", "Byte-swap and endian conversion helpers."],
+      "mem.heap" => ["Memory", "General-purpose heap allocator wrapper with alignment control."],
+      "mem.pool" => ["Memory", "Fixed-slot pool allocator for uniform-size objects."],
+      "mem.ptr" => ["Memory", "Safe pointer load/store wrappers around raw memory access."],
+      "mem.stack" => ["Memory", "Stack allocator with mark/release layered on the arena."],
+      "mem.tracking" => ["Memory", "Allocation tracker for leak detection and usage diagnostics."],
+      "multiset" => ["Collections", "Hash multiset that counts duplicate values."],
+      "net" => ["Network", "UDP and TCP sockets, address resolution, and packet I/O."],
+      "net.channel" => ["Network", "Multiplexed message channels over a single connection."],
+      "net.clock" => ["Network", "Synchronized network clock with ping and offset estimation."],
+      "net.discovery" => ["Network", "LAN service discovery via UDP broadcast."],
+      "net.lobby" => ["Network", "Lobby listing and joining built on discovery."],
+      "net.manager" => ["Network", "Connection and session manager for multiplayer topologies."],
+      "net.mux" => ["Network", "Stream multiplexer with reliable and unordered delivery flags."],
+      "net.nat" => ["Network", "NAT type detection and address binding via STUN."],
+      "net.packet" => ["Network", "Framed packet reading and writing over byte streams."],
+      "net.punch" => ["Network", "UDP hole punching for peer-to-peer connections."],
+      "net.rpc" => ["Network", "Request/response RPC framing over net channels."],
+      "net.session" => ["Network", "Client session state machine with heartbeats and timeouts."],
+      "net.stun" => ["Network", "STUN client for public address and port discovery."],
+      "net.sync" => ["Network", "State synchronization primitives for replicated values."],
+      "net.turn" => ["Network", "TURN relay client for NAT-restricted peers."],
+      "noise" => ["Math & Simulation", "Coherent Perlin noise and fractal variants."],
+      "oauth2" => ["Data & Serialization", "OAuth2 token requests and refresh flows."],
+      "option" => ["Core & Patterns", "Option[T] optional values, some(value) or none, with combinators."],
+      "ordered_map" => ["Collections", "Hash map that preserves insertion order."],
+      "ordered_set" => ["Collections", "Hash set that preserves insertion order."],
+      "parse" => ["Text & Formatting", "Numeric string parsing for integers and floats."],
+      "path" => ["Files & System", "Path join, split, and normalization utilities."],
+      "pcre2.runtime" => ["Text & Formatting", "Compiled regex matching runtime over the pcre2 bindings."],
+      "pool" => ["Collections", "Fixed-capacity reusable object storage."],
+      "priority_queue" => ["Collections", "Priority queue backed by a binary heap."],
+      "process" => ["Files & System", "Child process spawning with pipes and exit status."],
+      "queue" => ["Collections", "First-in first-out queue."],
+      "random" => ["Math & Simulation", "PCG pseudo-random number generation with seeding and ranges."],
+      "raylib.debug_console" => ["Game & Graphics", "In-game debug console overlay with command history."],
+      "raylib.easing" => ["Game & Graphics", "Easing curves for animation interpolation."],
+      "raylib.packed_assets" => ["Game & Graphics", "Load images, textures, and audio from assets.mtpack packs."],
+      "raylib.runtime" => ["Game & Graphics", "raylib app lifecycle helpers: window loop, asset directory, fatal errors."],
+      "raylib.tracy_gpu" => ["Game & Graphics", "Tracy profiler GPU zone calibration for raylib."],
+      "result" => ["Core & Patterns", "Result[T, E] success/failure type for recoverable errors."],
+      "ring_buffer" => ["Collections", "Fixed-capacity circular buffer with overwrite behavior."],
+      "sdl3.runtime" => ["Game & Graphics", "SDL3 app lifecycle helpers and main-loop wrappers."],
+      "serialize" => ["Data & Serialization", "Struct field serialization helpers layered on std.binary."],
+      "set" => ["Collections", "Hash set of unique values."],
+      "signal" => ["Concurrency & Time", "Fixed-capacity observer and publish-subscribe signals."],
+      "simd" => ["Math & Simulation", "SIMD load, store, and reduction helpers."],
+      "sparse_set" => ["Collections", "Sparse set with dense iteration for integer-keyed data."],
+      "spatial" => ["Math & Simulation", "Uniform spatial hash grid for broad-phase queries."],
+      "stack" => ["Collections", "Last-in first-out stack."],
+      "steering" => ["AI & Behavior", "Craig Reynolds steering behaviors for autonomous motion."],
+      "stdio" => ["Files & System", "Stdin, stdout, and stderr FILE wrappers and console I/O."],
+      "str" => ["Text & Formatting", "Borrowed string slice helpers: length, compare, search, split."],
+      "string" => ["Text & Formatting", "Heap-owned growable string type with builder operations."],
+      "sync" => ["Concurrency & Time", "Mutex, condition variable, and once primitives over libuv."],
+      "tar" => ["Data & Serialization", "TAR archive reading and writing with 512-byte blocks."],
+      "terminal" => ["Files & System", "Terminal size, color, and raw-mode helpers."],
+      "thread" => ["Concurrency & Time", "Threads via libuv with join and handle management."],
+      "time" => ["Concurrency & Time", "Wall-clock timestamps and monotonic time helpers."],
+      "timer" => ["Concurrency & Time", "Countdown and repeating timers."],
+      "tls" => ["Security", "TLS client and server streams over libuv handles."],
+      "toml" => ["Data & Serialization", "TOML parser for configuration files."],
+      "tween" => ["Game & Graphics", "Tweening and easing for smooth value interpolation."],
+      "uri" => ["Data & Serialization", "URI parsing and construction, including file and web schemes."],
+      "url" => ["Data & Serialization", "URL parsing: scheme, host, path, query, and percent-encoding."],
+      "utility" => ["AI & Behavior", "Utility AI with score-based action selection."],
+      "vec" => ["Collections", "Growable contiguous array Vec[T], the default dynamic sequence."],
+    }.freeze
+
+    class << self
+      def std_root
+        File.join(MilkTea.root.to_s, "std")
+      end
+
+      def entries
+        discover
+      end
+
+      # Resolves a module name ("mem.arena", "mem/arena", "c.cjson", "fs") to a
+      # source path. Prefers the active platform variant, matching the
+      # compiler's import resolution rule. Returns nil when unresolvable.
+      def resolve(name)
+        clean = name.to_s.strip
+        return nil if clean.empty? || clean.include?("..")
+
+        relative = clean.tr(".", "/").delete_suffix(".mt")
+        root = std_root
+
+        variant = File.join(root, "#{relative}.#{MilkTea.host_platform}.mt")
+        return variant if File.file?(variant)
+
+        shared = File.join(root, "#{relative}.mt")
+        return shared if File.file?(shared)
+
+        nil
+      end
+
+      def discover
+        root = std_root
+        by_name = {}
+
+        module_files(root).each do |path|
+          add_module(by_name, logical_name(path), path)
+        end
+
+        namespace_directories(root).each do |directory|
+          namespace = File.basename(directory)
+          module_files(directory).each do |path|
+            add_module(by_name, "#{namespace}.#{logical_name(path)}", path)
+          end
+        end
+
+        by_name.values.sort_by(&:name)
+      end
+
+      def add_module(by_name, name, path)
+        return if generated?(path)
+
+        category, description = REGISTRY.fetch(name, [nil, nil])
+        description ||= doc_comment_summary(path)
+        entry = by_name[name]
+        unless entry
+          by_name[name] = Entry.new(name:, description:, category:, path:)
+          return
+        end
+
+        entry.path = path if prefer_path?(path, entry.path)
+      end
+
+      # A shared file beats any variant; among variants the host platform
+      # wins, then the first alphabetically.
+      def prefer_path?(candidate, current)
+        candidate_rank = path_rank(candidate)
+        current_rank = path_rank(current)
+        order = candidate_rank <=> current_rank
+        order.negative? || (order.zero? && candidate < current)
+      end
+
+      def path_rank(path)
+        host = MilkTea.host_platform.to_s
+        [platform_variant?(path) ? 1 : 0, platform_of(path) == host ? 0 : 1]
+      end
+
+      def module_files(directory)
+        Dir.glob(File.join(directory, "*.mt")).sort
+      end
+
+      def namespace_directories(root)
+        Dir.children(root).map { |child| File.join(root, child) }
+           .select { |path| File.directory?(path) }
+           .reject { |path| EXCLUDED_DIRECTORIES.include?(File.basename(path)) }
+           .sort
+      end
+
+      def logical_name(path)
+        stem = File.basename(path, ".mt")
+        platform = platform_of(path)
+        platform ? stem.delete_suffix(".#{platform}") : stem
+      end
+
+      def platform_variant?(path)
+        PLATFORM_SUFFIXES.include?(platform_of(path))
+      end
+
+      def platform_of(path)
+        stem = File.basename(path, ".mt")
+        suffix = stem[/\.([^.]+)\z/, 1]
+        suffix && PLATFORM_SUFFIXES.include?(suffix) ? suffix : nil
+      end
+
+      def generated?(path)
+        File.open(path, "r") { |file| file.readline.start_with?(GENERATED_HEADER_PREFIX) }
+      rescue EOFError, Errno::ENOENT
+        false
+      end
+
+      def doc_comment_summary(path)
+        File.foreach(path) do |line|
+          stripped = line.strip
+          next if stripped.empty?
+
+          return stripped.sub(/\A##\s?/, "").rstrip if stripped.start_with?("##")
+
+          break
+        end
+        nil
+      rescue Errno::ENOENT
+        nil
+      end
+    end
+  end
+end

data/lib/milk_tea/tooling.rb

@@ -15,6 +15,7 @@ require_relative "tooling/error_formatter"
 require_relative "tooling/formatter"
 require_relative "tooling/linter"
 require_relative "tooling/docs_app"
+require_relative "tooling/std_catalog"
 require_relative "tooling/project_scaffold"
 require_relative "tooling/toolchain_cli"
 require_relative "tooling/bindgen_cli"

data/std/async/libuv_runtime.mt

@@ -79,23 +79,22 @@ function work_as_req(work: ptr[NativeWorkRequest]) -> ptr[NativeRequest]:
     return unsafe: ptr[NativeRequest]<-work
 
 
-function close_all_handles_cb(handle: ptr[NativeHandle], arg: ptr[void]) -> void:
+function close_all_handles_cb(handle: ptr[NativeHandle], _arg: ptr[void]) -> void:
     if libuv.is_closing(handle) == 0:
         libuv.close(handle, close_all_handles_close_cb)
-    unsafe: arg
 
 
-function close_all_handles_close_cb(handle: ptr[NativeHandle]) -> void:
-    unsafe: ptr[void]<-handle
+function close_all_handles_close_cb(_handle: ptr[NativeHandle]) -> void:
+    pass
 
 
-function noop_waiter(frame: ptr[void]) -> void:
-    unsafe: frame
+function noop_waiter(_frame: ptr[void]) -> void:
+    pass
 
 
 function require_current_runtime() -> Runtime:
     if not current_runtime_active:
-        fatal(c"async runtime requires an active runtime; use async.wait or async.run, or call the explicit *_on helpers")
+        fatal(c"async runtime requires an active runtime; use async.wait or async.run, or call the *_on helpers")
     return current_runtime
 
 
@@ -337,20 +336,19 @@ public function sleep_on(runtime: Runtime, timeout: ptr_uint) -> Task[int]:
     let loop = live_loop(runtime)
 
     let state = heap.must_alloc_zeroed[SleepState](1)
-    unsafe:
-        state.ready = false
-        state.status = 0
-        state.waiter_frame = null
-        state.waiter = noop_waiter
-        state.waiter_registered = false
-        state.timer = null
-        state.closing = false
-        state.closed = false
-        state.released = false
+    state.ready = false
+    state.status = 0
+    state.waiter_frame = null
+    state.waiter = noop_waiter
+    state.waiter_registered = false
+    state.timer = null
+    state.closing = false
+    state.closed = false
+    state.released = false
 
     let timer_size = libuv.handle_size(libuv.uv_handle_type.UV_TIMER)
     let timer = unsafe: ptr[NativeTimerHandle]<-heap.must_alloc_zeroed_bytes(1, timer_size)
-    unsafe: state.timer = timer
+    state.timer = timer
 
     let init_status = libuv.timer_init(loop, timer)
     if init_status != 0:
@@ -367,11 +365,10 @@ public function sleep_on(runtime: Runtime, timeout: ptr_uint) -> Task[int]:
 
     let start_status = libuv.timer_start(timer, sleep_timer_fire, timeout, 0)
     if start_status != 0:
-        unsafe:
-            state.status = start_status
-            state.ready = true
-            state.closing = true
-            libuv.close(timer_as_handle(timer), sleep_timer_close)
+        state.status = start_status
+        state.ready = true
+        state.closing = true
+        libuv.close(timer_as_handle(timer), sleep_timer_close)
 
     return sleep_task(state)
 

data/std/async/mailbox.mt

@@ -45,8 +45,8 @@ function handle_as_async(handle: ptr[NativeHandle]) -> ptr[NativeAsyncHandle]:
     return unsafe: ptr[NativeAsyncHandle]<-handle
 
 
-function mailbox_async_callback(handle: ptr[NativeAsyncHandle]) -> void:
-    unsafe: handle
+function mailbox_async_callback(_handle: ptr[NativeAsyncHandle]) -> void:
+    pass
 
 
 function mailbox_destroy_state[T](state_frame: ptr[void]) -> void:

data/std/base64.mt

@@ -163,18 +163,15 @@ public function decode(text_value: str) -> Result[bytes.Bytes, Error]:
 
         let combined = (ulong<-raw0 << 18) | (ulong<-raw1 << 12) | (ulong<-raw2 << 6) | ulong<-raw3
 
-        unsafe:
-            read(output + out_index) = ubyte<-( (combined >> 16) & 0xFF)
+        read(output + out_index) = ubyte<-( (combined >> 16) & 0xFF)
         out_index += 1
 
         if out_index < output_len:
-            unsafe:
-                read(output + out_index) = ubyte<-( (combined >> 8) & 0xFF)
+            read(output + out_index) = ubyte<-( (combined >> 8) & 0xFF)
             out_index += 1
 
         if out_index < output_len:
-            unsafe:
-                read(output + out_index) = ubyte<-(combined & 0xFF)
+            read(output + out_index) = ubyte<-(combined & 0xFF)
             out_index += 1
 
     return Result[bytes.Bytes, Error].success(value = bytes.Bytes(data = output, len = output_len))

data/std/behavior_tree.mt

@@ -233,11 +233,8 @@ function tick_node[Context](tree: ref[Tree[Context]], node_id: ptr_uint, context
                 match child_status:
                     Status.success:
                         return Status.success
-                    Status.failure:
-                        return Status.running
-                    Status.running:
+                    Status.failure | Status.running:
                         return Status.running
-
             NodeKind.until_failure:
                 let child_ptr = read(node).children.first() else:
                     return Status.failure
@@ -251,8 +248,6 @@ function tick_node[Context](tree: ref[Tree[Context]], node_id: ptr_uint, context
                     Status.running:
                         return Status.running
 
-    return Status.failure
-
 
 extending Node[Context]:
     static function create(kind: NodeKind) -> Node[Context]:

data/std/binary.mt

@@ -95,10 +95,7 @@ extending Writer:
 
 
     public editable function write_bool(value: bool) -> void:
-        if value:
-            writer_append_byte(ref_of(this), 1)
-        else:
-            writer_append_byte(ref_of(this), 0)
+        if value: writer_append_byte(ref_of(this), 1) else: writer_append_byte(ref_of(this), 0)
 
 
     public editable function write_bytes(data: span[ubyte]) -> void:
@@ -268,7 +265,7 @@ extending Reader:
 
     public editable function read_span(count: ptr_uint) -> Result[span[ubyte], Error]:
         if count == 0:
-            let empty = unsafe: span[ubyte](data = this.data.data, len = 0)
+            let empty = span[ubyte](data = this.data.data, len = 0)
             return Result[span[ubyte], Error].success(value = empty)
 
         reader_check_remaining(ref_of(this), count)?