mt-lang 0.4.24 → 0.4.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95423784419c8060f10277cb7abbb1fe1cd955fe648008781d1184976968e2d8
-  data.tar.gz: 6e1b33f4c2a17226dc34ba00618b89be6f329841c5badc7a53ccd022daa3c54d
+  metadata.gz: f4c65f190209c5486b52d39b2ac868b2e2c076ad3ec01206151df16675319cf9
+  data.tar.gz: 28bb0127501319fb64f0da085409bb8658b6fd9cd41d8c18c0ac2175608f93dd
 SHA512:
-  metadata.gz: aec1e36ac602ad755b89252058932df48abd25c0e645e212fa404afd25b23679e86d6cf45a970a36d566b08c9be774231496cf59766f64efa366da382e559963
-  data.tar.gz: 85af5d83647fd5cb635bec77a3ae8846be1b6f8f62638b5c82a2f99b9f76f2de6fb08455b6660e0cace75669e9281456a3d7336043ef3009988e50fc3efb4c0c
+  metadata.gz: '098dc1e2c0303bbf39dcd4402d7f21482c682f83b904799c1c85a9a73207b4c8443c0a98bdee192db9d17a0bf33ec4a96ad31c03a733f28c57880b7601c91d42'
+  data.tar.gz: ce0f5ba1ae8e8c6f958ab4cd5e2d0e89c522a9f814d8e5e31a1e8b8b849faafe437caaab098bd3a4d59755cdbf4f12c23d521810e9892c6e039acf27176b7d10

data/.ruby-version

@@ -1 +1 @@
-4.0.3
+4.0.6

data/Gemfile

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-ruby "4.0.3"
+ruby "4.0.6"
 
 gem "rake", "~> 13.4"
 gem "rexml", "~> 3.4"

data/Gemfile.lock

@@ -5,7 +5,7 @@ GEM
     drb (2.2.3)
     fiddle (1.1.8)
     logger (1.7.0)
-    minitest (6.0.4)
+    minitest (6.0.6)
       drb (~> 2.0)
       prism (~> 1.5)
     minitest-coverage (1.0.0.b3)
@@ -15,7 +15,7 @@ GEM
     puma (6.6.1)
       nio4r (~> 2.0)
     racc (1.8.1)
-    rack (3.2.6)
+    rack (3.2.7)
     rack-protection (4.2.1)
       base64 (>= 0.1.0)
       logger (>= 1.6.0)
@@ -34,7 +34,7 @@ GEM
       rack-protection (= 4.2.1)
       rack-session (>= 2.0.0, < 3)
       tilt (~> 2.0)
-    tilt (2.7.0)
+    tilt (2.9.0)
     tomlrb (2.0.4)
 
 PLATFORMS
@@ -58,25 +58,25 @@ CHECKSUMS
   drb (2.2.3) sha256=0b00d6fdb50995fe4a45dea13663493c841112e4068656854646f418fda13373
   fiddle (1.1.8) sha256=7fa8ee3627271497f3add5503acdbc3f40b32f610fc1cf49634f083ef3f32eee
   logger (1.7.0) sha256=196edec7cc44b66cfb40f9755ce11b392f21f7967696af15d274dde7edff0203
-  minitest (6.0.4) sha256=df1304664589d40f46089247fdc451f866b0ce0d7cae1457a15fc1eb7d48dca1
+  minitest (6.0.6) sha256=153ea36d1d987a62942382b61075745042a2b3123b1cd48f4c3675af9cc7d6f1
   minitest-coverage (1.0.0.b3) sha256=27c8b6b8df1259325dd206baa2b143c594f8a88b7dfd97fd8d3389a0e8a6ad26
   mustermann (3.1.1) sha256=4c6170c7234d5499c345562ba7c7dfe73e1754286dcc1abb053064d66a127198
   nio4r (2.7.5) sha256=6c90168e48fb5f8e768419c93abb94ba2b892a1d0602cb06eef16d8b7df1dca1
   prism (1.9.0) sha256=7b530c6a9f92c24300014919c9dcbc055bf4cdf51ec30aed099b06cd6674ef85
   puma (6.6.1) sha256=b9b56e4a4ea75d1bfa6d9e1972ee2c9f43d0883f011826d914e8e37b3694ea1e
   racc (1.8.1) sha256=4a7f6929691dbec8b5209a0b373bc2614882b55fc5d2e447a21aaa691303d62f
-  rack (3.2.6) sha256=5ed78e1f73b2e25679bec7d45ee2d4483cc4146eb1be0264fc4d94cb5ef212c2
+  rack (3.2.7) sha256=93e13e1c24f93556671d85d2d79fa228c3485815c50d7e2f265b5330c6528fb7
   rack-protection (4.2.1) sha256=cf6e2842df8c55f5e4d1a4be015e603e19e9bc3a7178bae58949ccbb58558bac
   rack-session (2.1.2) sha256=595434f8c0c3473ae7d7ac56ecda6cc6dfd9d37c0b2b5255330aa1576967ffe8
   rackup (2.3.1) sha256=6c79c26753778e90983761d677a48937ee3192b3ffef6bc963c0950f94688868
   rake (13.4.2) sha256=cb825b2bd5f1f8e91ca37bddb4b9aaf345551b4731da62949be002fa89283701
   rexml (3.4.4) sha256=19e0a2c3425dfbf2d4fc1189747bdb2f849b6c5e74180401b15734bc97b5d142
   sinatra (4.2.1) sha256=b7aeb9b11d046b552972ade834f1f9be98b185fa8444480688e3627625377080
-  tilt (2.7.0) sha256=0d5b9ba69f6a36490c64b0eee9f6e9aad517e20dcc848800a06eb116f08c6ab3
+  tilt (2.9.0) sha256=da5735d0280bba96e9a91041bb14aee435ccad5c17b0fa519249ae543d9aa3a5
   tomlrb (2.0.4) sha256=262f77947ac3ac9b3366a0a5940ecd238300c553e2e14f22009e2afcd2181b99
 
 RUBY VERSION
-  ruby 4.0.3
+  ruby 4.0.6
 
 BUNDLED WITH
-  4.0.3
+  4.0.16

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/core/control_flow/builder.rb

@@ -352,6 +352,12 @@ module MilkTea
           read_identifiers(expression.expression, names, reads_info)
         when AST::UnsafeExpr
           read_identifiers(expression.expression, names, reads_info)
+        when AST::PrefixCast
+          read_identifiers(expression.expression, names, reads_info)
+        when AST::DetachExpr
+          expression.body.each do |stmt|
+            read_identifiers(stmt.expression, names, reads_info) if stmt.is_a?(AST::ExpressionStmt)
+          end
         when AST::FormatString
           expression.parts.each do |part|
             read_identifiers(part.expression, names, reads_info) if part.is_a?(AST::FormatExprPart)
@@ -433,6 +439,12 @@ module MilkTea
           end
         when AST::UnsafeExpr
           write_targets_from_expression(expression.expression, line:, writes:, writes_info:)
+        when AST::PrefixCast
+          write_targets_from_expression(expression.expression, line:, writes:, writes_info:)
+        when AST::DetachExpr
+          expression.body.each do |stmt|
+            write_targets_from_expression(stmt.expression, line:, writes:, writes_info:) if stmt.is_a?(AST::ExpressionStmt)
+          end
         when AST::FormatString
           expression.parts.each do |part|
             write_targets_from_expression(part.expression, line:, writes:, writes_info:) if part.is_a?(AST::FormatExprPart)

data/lib/milk_tea/tooling/cli/commands/std.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandStd
+      def std_command
+        subcommand = @argv.shift
+
+        case subcommand
+        when "list"
+          std_list_command
+        when "show"
+          std_show_command
+        when nil
+          @err.puts("missing std subcommand (expected list or show)")
+          print_command_help("std", @err)
+          1
+        else
+          @err.puts("unknown std subcommand #{subcommand}")
+          print_command_help("std", @err)
+          1
+        end
+      end
+
+      def std_list_command
+        as_json = false
+        until @argv.empty?
+          option = @argv.shift
+          case option
+          when "--json"
+            as_json = true
+          else
+            @err.puts("unknown std list option #{option}")
+            return 1
+          end
+        end
+
+        entries = StdCatalog.entries
+        if as_json
+          @out.puts(JSON.generate(entries.map(&:to_h)))
+          return 0
+        end
+
+        print_std_list(entries)
+        0
+      end
+
+      def print_std_list(entries)
+        name_width = entries.map { |entry| entry.name.length }.max
+        description_width = entries.map { |entry| entry.description&.length.to_i }.max
+
+        StdCatalog::CATEGORY_ORDER.each do |category|
+          category_entries = entries.select { |entry| entry.category == category }
+          next if category_entries.empty?
+
+          @out.puts("#{category}:")
+          category_entries.each do |entry|
+            description = entry.description || "(no description)"
+            @out.puts("  #{entry.name.ljust(name_width)}  #{description.ljust(description_width)}  #{entry.path}")
+          end
+          @out.puts
+        end
+      end
+
+      def std_show_command
+        name = @argv.shift
+        unless name
+          @err.puts("missing module name")
+          print_command_help("std", @err)
+          return 1
+        end
+
+        path = StdCatalog.resolve(name)
+        unless path
+          @err.puts("std module not found: #{name}")
+          return 1
+        end
+
+        @out.write(File.read(path))
+        0
+      end
+    end
+  end
+end

data/lib/milk_tea/tooling/cli.rb

@@ -33,6 +33,7 @@ module MilkTea
       ["bindgen",     "Generate a binding module from a C header"],
       ["cache",       "Inspect and manage the build cache"],
       ["docs",        "Serve the local documentation site"],
+      ["std",         "List standard library modules and print their source"],
       ["snapshot",    "Render a highlighted HTML snapshot"],
       ["lsp",         "Start the Language Server Protocol server"],
       ["dap",         "Start the Debug Adapter Protocol server"],
@@ -127,6 +128,8 @@ module MilkTea
         cache_command
       when "docs"
         docs_command
+      when "std"
+        std_command
       when "snapshot"
         snapshot_command
       when "lsp"
@@ -164,6 +167,7 @@ module MilkTea
     require_relative "cli/commands/bindgen"
     require_relative "cli/commands/cache"
     require_relative "cli/commands/docs"
+    require_relative "cli/commands/std"
     require_relative "cli/commands/snapshot"
     require_relative "cli/commands/lsp"
     require_relative "cli/commands/dap"
@@ -187,6 +191,7 @@ module MilkTea
     include CommandBindgen
     include CommandCache
     include CommandDocs
+    include CommandStd
     include CommandSnapshot
     include CommandLsp
     include CommandDap
@@ -796,6 +801,24 @@ module MilkTea
             --open, -o            Open the docs in your default browser.
             --port, -p PORT       Listen on a specific port (default: random).
         HELP
+      "std"             => <<~HELP,
+        Usage: mtc std list [--json]
+               mtc std show MODULE
+
+          Inspect the Milk Tea standard library shipped in std/.
+
+          list    Print every hand-written standard library module with a short
+                  description and its path on disk, grouped by category.
+                  Generated binding modules (std/c/* and imported-binding
+                  wrappers such as raylib or zstd) are not listed.
+          show    Print the source of a module. Accepts dotted or slashed names
+                  (mem.arena, mem/arena) and resolves platform variants such as
+                  fs to the active platform file. Generated modules stay
+                  viewable here (for example c.cjson or raylib).
+
+          Options:
+            --json    Emit list output as JSON.
+        HELP
       "snapshot"        => <<~HELP,
         Usage: mtc snapshot INPUT.mt [OPTIONS]
 
@@ -891,6 +914,8 @@ module MilkTea
       io.puts("       mtc bindgen MODULE HEADER [-o OUTPUT] [--nullable-report PATH] [--link LIB] [--include HEADER] [--clang PATH] [--clang-arg ARG]")
       io.puts("       mtc cache purge|status")
       io.puts("       mtc docs [--open] [--port PORT]")
+      io.puts("       mtc std list [--json]")
+      io.puts("       mtc std show MODULE")
       io.puts("       mtc snapshot INPUT.mt [--theme PATH] [-o OUTPUT]")
       io.puts("       mtc lsp [--log-level LEVEL] [--stdio]")
       io.puts("       mtc dap [--backend KIND] [--adapter-path PATH]")

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

@@ -17,6 +17,7 @@ module MilkTea
         when "redundant-else"         then redundant_else_edits(lines, warning)
         when "redundant-return"       then redundant_return_edits(lines, warning)
         when "redundant-type-annotation" then redundant_type_annotation_edits(lines, warning)
+        when "redundant-unsafe"       then redundant_unsafe_edits(lines, warning)
         when "prefer-inline-methods"  then prefer_inline_methods_edits(lines, warning)
         when "unused-import"          then unused_import_edits(lines, warning)
         when "trailing-list-comma"    then trailing_list_comma_edits(lines, warning)
@@ -302,6 +303,105 @@ module MilkTea
         edits
       end
 
+      # ── redundant-unsafe ───────────────────────────────────────────────────
+      # Removes an `unsafe:` wrapper that contains no unsafe operations.
+      #
+      # Supported shapes:
+      #   <indent>unsafe:\n<deeper body>   (block statement; body is dedented)
+      #   ... unsafe: expr ...             (inline expression on a single line)
+      def self.redundant_unsafe_edits(lines, warning)
+        return [] unless warning.line
+
+        line_idx = warning.line - 1
+        line = lines[line_idx]
+        return [] unless line
+
+        unsafe_idx = line.index("unsafe:")
+        return [] unless unsafe_idx
+
+        keyword_end = unsafe_idx + "unsafe:".length
+        rest = line[keyword_end..]
+
+        if rest && !rest.strip.empty?
+          # Inline expression form: drop the keyword and the whitespace after
+          # it, but only when the remainder is balanced on this line.
+          remainder = rest.sub(/\A\s+/, "")
+          return [] if remainder.empty? || !balanced_line?(remainder)
+
+          return [FixEdit.new(
+            start_line: line_idx,
+            start_char: unsafe_idx,
+            end_line: line_idx,
+            end_char: keyword_end + (rest.length - remainder.length),
+            new_text: "",
+          )]
+        end
+
+        # Block statement form: `unsafe:` alone, body indented deeper.
+        indent = line[0...unsafe_idx]
+        return [] unless indent.match?(/\A *\z/)
+
+        body_start = line_idx + 1
+        body_indent = nil
+        last_body = nil
+        (body_start...lines.length).each do |i|
+          candidate = lines[i]
+          if candidate.nil? || candidate.strip.empty?
+            last_body = i
+            next
+          end
+
+          break unless candidate.start_with?(indent + " ")
+
+          body_indent ||= candidate[/\A */].length - indent.length
+          last_body = i
+        end
+
+        return [] if last_body.nil? || last_body < body_start
+        return [] if body_indent.nil? || body_indent <= 0
+        return [] unless (body_start..last_body).all? do |i|
+          l = lines[i]
+          l.nil? || l.strip.empty? || l.start_with?(indent + " " * body_indent)
+        end
+
+        replacement = (body_start..last_body).map do |i|
+          l = lines[i]
+          l.nil? || l.strip.empty? ? "" : l[body_indent..].to_s.chomp
+        end
+
+        if last_body + 1 <= lines.length - 1
+          # Consume through the first following line; apply_fix_edits re-emits
+          # it as the suffix of a multi-line replacement.
+          end_line = last_body + 1
+          end_char = 0
+        else
+          end_line = last_body
+          end_char = lines[last_body].to_s.length
+        end
+
+        [FixEdit.new(
+          start_line: line_idx,
+          start_char: 0,
+          end_line:,
+          end_char:,
+          new_text: replacement.join("\n") + "\n",
+        )]
+      end
+
+      def self.balanced_line?(text)
+        depth = 0
+        text.each_char do |char|
+          case char
+          when "(", "["
+            depth += 1
+          when ")", "]"
+            depth -= 1
+            return false if depth.negative?
+          end
+        end
+        depth.zero?
+      end
+
       def self.match_paren(line, open_pos)
         depth = 0
         (open_pos...line.length).each do |i|

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

@@ -258,10 +258,28 @@ module MilkTea
         case expr
         when AST::Call
           expr.arguments.any? do |arg|
-            next unless arg.is_a?(AST::Argument)
+            next false unless arg.is_a?(AST::Argument)
 
-            arg.value.is_a?(AST::Identifier) && arg.value.name == name ||
-              own_struct_field_transfer?(arg.value, name)
+            own_transfer_identifier?(arg.value, name)
+          end
+        when AST::PrefixCast
+          own_transfer_identifier?(expr.expression, name)
+        else
+          false
+        end
+      end
+
+      def own_transfer_identifier?(value, name)
+        case value
+        when AST::Identifier
+          value.name == name
+        when AST::PrefixCast
+          own_transfer_identifier?(value.expression, name)
+        when AST::Call
+          value.arguments.any? do |arg|
+            next false unless arg.is_a?(AST::Argument)
+
+            own_transfer_identifier?(arg.value, name)
           end
         else
           false
@@ -426,15 +444,29 @@ module MilkTea
         return false unless expr.is_a?(AST::Call)
 
         expr.arguments.any? do |arg|
-          next false unless arg.is_a?(AST::Argument) && arg.name
-
-          if arg.value.is_a?(AST::Identifier) && arg.value.name == name
-            true
-          elsif arg.value.is_a?(AST::Call)
-            _expr_contains_transfer?(arg.value, name)
-          else
-            false
+          named = arg.is_a?(AST::Argument) && !arg.name.nil?
+          argument_transfers?(arg.value, name, named)
+        end
+      end
+
+      # An identifier passed as a named argument transfers ownership (struct
+      # field initialization), even when wrapped in a pointer cast
+      # (e.g. handle_set_data(h, ptr[void]<-state)). Nested calls are walked
+      # so `queue.push(Foo(field = x))` recognizes the inner transfer.
+      def argument_transfers?(value, name, named)
+        case value
+        when AST::Identifier
+          named && value.name == name
+        when AST::PrefixCast
+          inner = value.expression
+          inner.is_a?(AST::Identifier) && inner.name == name
+        when AST::Call
+          value.arguments.any? do |arg|
+            nested_named = arg.is_a?(AST::Argument) && !arg.name.nil?
+            argument_transfers?(arg.value, name, nested_named)
           end
+        else
+          false
         end
       end
 
@@ -481,6 +513,9 @@ module MilkTea
         return if expr.nil?
 
         result << expr.callee.receiver.name if release_call_on_binding?(expr)
+        if expr.is_a?(AST::Call) && expr.callee.is_a?(AST::Identifier) && expr.callee.name.start_with?("release_")
+          result.merge(release_helper_binding_names(expr))
+        end
 
         case expr
         when AST::Call
@@ -496,6 +531,26 @@ module MilkTea
         end
       end
 
+      # std convention: `release_*` helper functions take ownership of the
+      # bindings handed to them via ref_of/ptr_of, e.g.
+      # `release_string_values(ref_of(values))`. Treat those bindings as
+      # released so the leak rule understands the cleanup-helper idiom.
+      def release_helper_binding_names(expr)
+        names = Set.new
+        expr.arguments.each do |arg|
+          value = arg.respond_to?(:value) ? arg.value : nil
+          next unless value.is_a?(AST::Call)
+          next unless value.callee.is_a?(AST::Identifier)
+          next unless %w[ref_of ptr_of].include?(value.callee.name)
+
+          value.arguments.each do |inner|
+            binding_name = inner.value
+            names << binding_name.name if binding_name.is_a?(AST::Identifier)
+          end
+        end
+        names
+      end
+
       def _any_stmt?(stmts, &pred)
         return false if stmts.nil?
 
@@ -620,6 +675,9 @@ module MilkTea
         return false unless expr
 
         return true if release_call_on_binding?(expr) && expr.callee.receiver.name == name
+        return true if expr.is_a?(AST::Call) && expr.callee.is_a?(AST::Identifier) &&
+                       expr.callee.name.start_with?("release_") &&
+                       release_helper_binding_names(expr).include?(name)
 
         case expr
         when AST::Call

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:,