mt-lang 0.4.24 → 0.4.26

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/core/lowering/utils.rb

@@ -127,6 +127,13 @@ module MilkTea
 
       def infer_value_type(handle_expression, env:)
         handle_type = infer_expression_type(handle_expression, env:)
+        # BUG FIX: nullable pointer handles (ptr[T]?) read through as their
+        # base pointer type; std/net relies on this after flow-unguarded
+        # null checks on storage fields.
+        if handle_type.is_a?(Types::Nullable) &&
+           (ref_type?(handle_type.base) || pointer_type?(handle_type.base))
+          handle_type = handle_type.base
+        end
         return referenced_type(handle_type) if ref_type?(handle_type)
         return pointee_type(handle_type) if pointer_type?(handle_type)
 
@@ -371,7 +378,7 @@ module MilkTea
           elements = value.map { |element| lower_compile_time_literal(element, element_type) }
           return nil if elements.any?(&:nil?)
 
-          IR::ArrayLiteral.new(type:, elements:)
+          return IR::ArrayLiteral.new(type:, elements:)
         when Hash
           return nil unless type.is_a?(Types::Struct)
           fields = value.map do |name, field_value|

data/lib/milk_tea/core/semantic_analyzer/expressions.rb

@@ -721,8 +721,10 @@ module MilkTea
               raise_sema_error("operator #{expression.operator} is not supported for type #{bad_type}")
             end
           end
-          unless common_numeric_type(left_type, right_type) || types_compatible?(left_type, right_type) || types_compatible?(right_type, left_type)
-            raise_sema_error("operator #{expression.operator} requires comparable types, got #{left_type} and #{right_type}")
+          unless common_numeric_type(left_type, right_type) || types_compatible?(left_type, right_type) || types_compatible?(right_type, left_type) || refined_null_comparison?(expression, scopes)
+            message = "operator #{expression.operator} requires comparable types, got #{left_type} and #{right_type}"
+            hint = null_comparison_hint(left_type, right_type)
+            raise_sema_error(hint ? "#{message}; #{hint}" : message)
           end
 
           @ctx.types.fetch("bool")
@@ -731,6 +733,45 @@ module MilkTea
         end
       end
 
+      # A null comparison on a nullable binding stays legal after flow
+      # refinement has narrowed the binding to non-null: the declared storage
+      # is still nullable, and the check is a redundant-but-valid test (the
+      # linter reports it as redundant-null-check). Only bare `null` qualifies;
+      # a typed `null[...]` with a mismatched target stays a type error.
+      def refined_null_comparison?(expression, scopes)
+        if expression.left.is_a?(AST::NullLiteral) && expression.left.type.nil? && expression.right.is_a?(AST::Identifier)
+          identifier_expression = expression.right
+        elsif expression.right.is_a?(AST::NullLiteral) && expression.right.type.nil? && expression.left.is_a?(AST::Identifier)
+          identifier_expression = expression.left
+        else
+          return false
+        end
+
+        binding = lookup_value(identifier_expression.name, scopes)
+        binding&.storage_type.is_a?(Types::Nullable)
+      end
+
+      # A null comparison against a non-nullable operand is a contract mismatch,
+      # not just incompatible operand types: the message should say which fix
+      # applies (nullable declaration, raw zero comparison, or removal).
+      def null_comparison_hint(left_type, right_type)
+        other = if left_type.is_a?(Types::Null) && !right_type.is_a?(Types::Null)
+          right_type
+        elsif right_type.is_a?(Types::Null) && !left_type.is_a?(Types::Null)
+          left_type
+        end
+        return nil unless other
+        return nil if other.is_a?(Types::Nullable) || other.is_a?(Types::Null)
+
+        if ref_type?(other)
+          "#{other} is never null by design; refs cannot be compared against null"
+        elsif pointer_type?(other) || opaque_type?(other) || other == Types::Registry.primitive("cstr")
+          hint = "#{other} is declared non-null; declare it #{other}? if null is possible"
+          hint << ", or compare against zero[#{other}] for raw zero-pointer storage" if zero_supported_type?(other)
+          hint
+        end
+      end
+
       def infer_if_expression(expression, scopes:, expected_type: nil)
         condition_type = infer_expression(expression.condition, scopes:, expected_type: @ctx.types.fetch("bool"))
         ensure_assignable!(condition_type, @ctx.types.fetch("bool"), "if expression condition must be bool, got #{condition_type}")

data/lib/milk_tea/core/semantic_analyzer/name_resolution.rb

@@ -740,6 +740,12 @@ module MilkTea
       end
 
       def zero_initializable_type?(type, operation: "zero")
+        return true if zero_supported_type?(type)
+
+        raise_sema_error("#{operation} does not support type #{type}")
+      end
+
+      def zero_supported_type?(type)
         return true if type.is_a?(Types::Primitive) && !type.void?
         return true if type.is_a?(Types::Nullable)
         return true if type.is_a?(Types::EnumBase)
@@ -761,7 +767,7 @@ module MilkTea
         return true if simd_type?(type)
         return true if atomic_type?(type)
 
-        raise_sema_error("#{operation} does not support type #{type}")
+        false
       end
 
       def layout_aggregate_type?(type)

data/lib/milk_tea/tooling/bindgen_cli.rb

@@ -101,6 +101,11 @@ module MilkTea
           return missing_option_value(option) unless value
 
           options[:nullable_report_path] = value
+        when "--nullable-policy"
+          value = @argv.shift
+          return missing_option_value(option) unless value
+
+          options[:nullable_policy_path] = value
         else
           @err.puts("unknown bindgen option #{option}")
           print_help
@@ -109,9 +114,60 @@ module MilkTea
       end
 
       options[:include_directives] = nil if options[:include_directives].empty?
+      if options[:nullable_policy_path]
+        policy = load_nullable_policy(options.delete(:nullable_policy_path))
+        return nil unless policy
+
+        options[:function_return_type_overrides] = policy[:return_types]
+        options[:function_param_type_overrides] = policy[:parameters]
+      end
       options
     end
 
+    # A nullable policy lists the symbols a header documents as returning NULL
+    # (or taking NULL-able out-pointers) so generated raw bindings expose them
+    # as nullable `T?` without hand-annotating the C header. Entries feed the
+    # same function_return_type_overrides / function_param_type_overrides
+    # machinery as the raw binding registry and appear in the nullable report.
+    def load_nullable_policy(path)
+      require "json"
+      policy_path = File.expand_path(path)
+      unless File.file?(policy_path)
+        @err.puts("nullable policy file not found: #{path}")
+        return nil
+      end
+
+      document = begin
+        JSON.parse(File.read(policy_path))
+      rescue JSON::ParserError => e
+        @err.puts("nullable policy is not valid JSON: #{e.message}")
+        return nil
+      end
+
+      unless document.is_a?(Hash)
+        @err.puts("nullable policy must be a JSON object")
+        return nil
+      end
+
+      unknown_keys = document.keys - ["return_types", "parameters"]
+      unless unknown_keys.empty?
+        @err.puts("nullable policy has unknown keys: #{unknown_keys.join(', ')} (expected return_types, parameters)")
+        return nil
+      end
+
+      return_types = document["return_types"] || {}
+      parameters = document["parameters"] || {}
+      policy_shape_valid = return_types.is_a?(Hash) && return_types.keys.all?(String) && return_types.values.all?(String) &&
+        parameters.is_a?(Hash) && parameters.keys.all?(String) &&
+        parameters.values.all? { |value| value.is_a?(Hash) && value.keys.all?(String) && value.values.all?(String) }
+      unless policy_shape_valid
+        @err.puts('nullable policy must map {"return_types": {symbol: "type?"}, "parameters": {symbol: {param: "type?"}}}')
+        return nil
+      end
+
+      { return_types:, parameters: }
+    end
+
     def missing_option_value(option)
       @err.puts("missing value for #{option}")
       print_help

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
@@ -771,6 +776,7 @@ module MilkTea
 
           Options:
             -o, --output OUTPUT    Write the generated module to this file.
+            --nullable-policy PATH Apply a JSON nullable policy of symbols documented as returning NULL.
             --nullable-report PATH Write the remaining manual nullable policy report to this file.
             --link LIB             Link against this library (repeatable).
             --include HEADER       Extra #include directive (repeatable).
@@ -796,6 +802,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]
 
@@ -888,9 +912,11 @@ module MilkTea
       io.puts("       mtc deps lock [PATH_OR_PACKAGE] [--check]")
       io.puts("       mtc deps publish [PATH_OR_PACKAGE] [--upstream]")
       io.puts("       mtc deps fetch [PATH_OR_PACKAGE]")
-      io.puts("       mtc bindgen MODULE HEADER [-o OUTPUT] [--nullable-report PATH] [--link LIB] [--include HEADER] [--clang PATH] [--clang-arg ARG]")
+      io.puts("       mtc bindgen MODULE HEADER [-o OUTPUT] [--nullable-policy PATH] [--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