Implement changes of ruby-3.0 to IO#wait

CHANGELOG.md

@@ -117,6 +117,7 @@ Compatibility:
 * Add `Refinement#import_methods` method and add deprecation warning for `Refinement#include` and `Refinement#prepend` (#2733, @horakivo).
 * Upgrading `UNICODE` version to 13.0.0 and `EMOJI` version to 13.1 (#2733, @horakivo).
 * Add `rb_io_maybe_wait_readable`, `rb_io_maybe_wait_writable` and `rb_io_maybe_wait` functions (#2733, @andrykonchin).
+* Implement changes of Ruby 3.0 to `IO#wait` (#2953, @larskanis).
 
 Performance:
 

lib/truffle/io/wait.rb

@@ -1,3 +1,5 @@
+# truffleruby_primitives: true
+
 # Copyright (c) 2017, 2023 Oracle and/or its affiliates. All rights reserved. This
 # code is released under a tri EPL/GPL/LGPL license. You can use it,
 # redistribute it and/or modify it under the terms of the:
@@ -14,17 +16,77 @@ def nread
 
   def ready?
     ensure_open_and_readable
-    Truffle::IOOperations.poll(self, Truffle::IOOperations::POLLIN, 0)
+    Truffle::IOOperations.poll(self, IO::READABLE, 0) > 0
   end
 
   def wait_readable(timeout = nil)
     ensure_open_and_readable
-    Truffle::IOOperations.poll(self, Truffle::IOOperations::POLLIN, timeout) ? self : nil
+    Truffle::IOOperations.poll(self, IO::READABLE, timeout) > 0 ? self : nil
   end
-  alias_method :wait, :wait_readable
 
   def wait_writable(timeout = nil)
     ensure_open_and_writable
-    Truffle::IOOperations.poll(self, Truffle::IOOperations::POLLOUT, timeout) ? self : nil
+    Truffle::IOOperations.poll(self, IO::WRITABLE, timeout) > 0 ? self : nil
+  end
+
+  def wait_priority(timeout = nil)
+    ensure_open_and_readable
+    Truffle::IOOperations.poll(self, IO::PRIORITY, timeout) > 0 ? self : nil
+  end
+
+
+  # call-seq:
+  #   io.wait(events, timeout) -> event mask, false or nil
+  #   io.wait(timeout = nil, mode = :read) -> self, true, or false
+  #
+  # Waits until the IO becomes ready for the specified events and returns the
+  # subset of events that become ready, or a falsy value when times out.
+  #
+  # The events can be a bit mask of +IO::READABLE+, +IO::WRITABLE+ or
+  # +IO::PRIORITY+.
+  #
+  # Returns a truthy value immediately when buffered data is available.
+  #
+  # Optional parameter +mode+ is one of +:read+, +:write+, or
+  # +:read_write+.
+  def wait(*args)
+    ensure_open
+
+    if args.size != 2 || Primitive.object_kind_of?(args[0], Symbol) || Primitive.object_kind_of?(args[1], Symbol)
+      # Slow/messy path:
+      timeout = :undef
+      events = 0
+      args.each do |arg|
+        if Primitive.object_kind_of?(arg, Symbol)
+          events |= case arg
+                    when :r, :read, :readable then IO::READABLE
+                    when :w, :write, :writable then IO::WRITABLE
+                    when :rw, :read_write, :readable_writable then IO::READABLE | IO::WRITABLE
+                    else
+                      raise ArgumentError, "unsupported mode: #{mode.inspect}"
+                    end
+
+        elsif timeout == :undef
+          timeout = arg
+        else
+          raise ArgumentError, 'timeout given more than once'
+        end
+      end
+
+      timeout = nil if timeout == :undef
+
+      events = IO::READABLE if events == 0
+
+      res = Truffle::IOOperations.poll(self, events, timeout)
+      res == 0 ? nil : self
+    else
+      # args.size == 2 and neither are symbols
+      # This is the fast path and the new interface:
+      events, timeout = *args
+      raise ArgumentError, 'Events must be positive integer!' if events <= 0
+      res = Truffle::IOOperations.poll(self, events, timeout)
+      # return events as bit mask
+      res == 0 ? nil : res
+    end
   end
 end

src/main/c/truffleposix/truffleposix.c

@@ -117,7 +117,7 @@ int truffleposix_poll(int fd, int events, int timeout_ms) {
   fds.fd = fd;
   fds.events = events;
 
-  return poll(&fds, 1, timeout_ms);
+  return poll(&fds, 1, timeout_ms) >= 0 ? fds.revents : -1;
 }
 
 int truffleposix_select(int nread, int *readfds, int nwrite, int *writefds,

src/main/ruby/truffleruby/core/truffle/io_operations.rb

@@ -205,9 +205,9 @@ def self.select(readables, readable_ios, writables, writable_ios, errorables, er
 
     end
 
-    # This method will return a true if poll returned without error
-    # with an event within the timeout, false if the timeout expired,
-    # or raises an exception for an errno.
+    # This method will return an event mask if poll returned without error.
+    # The event mask is > 0 when an event occurred within the timeout, 0 if the timeout expired.
+    # Raises an exception for an errno.
     def self.poll(io, event_mask, timeout)
       if (event_mask & POLLIN) != 0
         return 1 unless io.__send__(:buffer_empty?)
@@ -257,7 +257,7 @@ def self.poll(io, event_mask, timeout)
               Errno.handle_errno(errno)
             end
           else
-            primitive_result > 0
+            primitive_result
           end
       end while result == :retry
 

test/mri/excludes/TestIOWait.rb

@@ -1,12 +1,4 @@
-exclude :test_nread, "needs investigation"
-exclude :test_nread_buffered, "needs investigation"
-exclude :test_wait_buffered, "needs investigation"
-exclude :test_wait_readable_buffered, "needs investigation"
-exclude :test_wait_readwrite, "needs investigation"
-exclude :test_wait_readwrite_timeout, "needs investigation"
-exclude :test_nread, "needs investigation"
-exclude :test_nread_buffered, "needs investigation"
-exclude :test_wait_buffered, "needs investigation"
-exclude :test_wait_readable_buffered, "needs investigation"
-exclude :test_wait_readwrite, "needs investigation"
-exclude :test_wait_readwrite_timeout, "needs investigation"
+exclude :test_nread, "buffered reads are not implemented"
+exclude :test_nread_buffered, "buffered reads are not implemented"
+exclude :test_wait_buffered, "buffered reads are not implemented"
+exclude :test_wait_readable_buffered, "buffered reads are not implemented"

test/mri/tests/io/wait/test_io_wait.rb

@@ -3,10 +3,9 @@
 require 'test/unit'
 require 'timeout'
 require 'socket'
-begin
-  require 'io/wait'
-rescue LoadError
-end
+
+# For `IO#ready?` and `IO#nread`:
+require 'io/wait'
 
 class TestIOWait < Test::Unit::TestCase
 
@@ -50,6 +49,7 @@ def test_buffered_ready?
   end
 
   def test_wait
+    omit 'unstable on MinGW' if /mingw/ =~ RUBY_PLATFORM
     assert_nil @r.wait(0)
     @w.syswrite "."
     sleep 0.1
@@ -161,6 +161,34 @@ def test_wait_readwrite_timeout
     assert_equal @w, @w.wait(0.01, :read_write)
   end
 
+  def test_wait_mask_writable
+    omit("Missing IO::WRITABLE!") unless IO.const_defined?(:WRITABLE)
+    assert_equal IO::WRITABLE, @w.wait(IO::WRITABLE, 0)
+  end
+
+  def test_wait_mask_readable
+    omit("Missing IO::READABLE!") unless IO.const_defined?(:READABLE)
+    @w.write("Hello World\n" * 3)
+    assert_equal IO::READABLE, @r.wait(IO::READABLE, 0)
+
+    @r.gets
+    assert_equal IO::READABLE, @r.wait(IO::READABLE, 0)
+  end
+
+  def test_wait_mask_zero
+    omit("Missing IO::WRITABLE!") unless IO.const_defined?(:WRITABLE)
+    assert_raise(ArgumentError) do
+      @w.wait(0, 0)
+    end
+  end
+
+  def test_wait_mask_negative
+    omit("Missing IO::WRITABLE!") unless IO.const_defined?(:WRITABLE)
+    assert_raise(ArgumentError) do
+      @w.wait(-6, 0)
+    end
+  end
+
 private
 
   def fill_pipe