Merge branch 'master' into bundled_bigdecimal

Author: tompng

NEWS.md

@@ -98,6 +98,24 @@ Note: We're only listing outstanding class updates.
       `Binding#implicit_parameter_defined?` have been added to access
       numbered parameters and "it" parameter. [[Bug #21049]]
 
+* ErrorHighlight
+
+    * When an ArgumentError is raised, it now displays code snippets for
+      both the method call (caller) and the method definition (callee).
+      [[Feature #21543]]
+
+      ```
+      test.rb:1:in 'Object#add': wrong number of arguments (given 1, expected 2) (ArgumentError)
+
+          caller: test.rb:3
+          | add(1)
+            ^^^
+          callee: test.rb:1
+          | def add(x, y) = x + y
+                ^^^
+              from test.rb:3:in '<main>'
+      ```
+
 * File
 
     * `File::Stat#birthtime` is now available on Linux via the statx
@@ -347,6 +365,31 @@ The following bundled gems are updated.
   and was already deprecated,.
   [[Feature #20971]]
 
+* A backtrace for `ArgumentError` of "wrong number of arguments" now
+  include the receiver's class or module name (e.g., in `Foo#bar`
+  instead of in `bar`). [[Bug #21698]]
+
+* Backtraces no longer display `internal` frames.
+  These methods now appear as if it is in the Ruby source file,
+  consistent with other C-implemented methods. [[Bug #20968]]
+
+  Before:
+  ```
+  ruby -e '[1].fetch_values(42)'
+  <internal:array>:211:in 'Array#fetch': index 42 outside of array bounds: -1...1 (IndexError)
+          from <internal:array>:211:in 'block in Array#fetch_values'
+          from <internal:array>:211:in 'Array#map!'
+          from <internal:array>:211:in 'Array#fetch_values'
+          from -e:1:in '<main>'
+  ```
+
+  After:
+  ```
+  $ ruby -e '[1].fetch_values(42)'
+  -e:1:in 'Array#fetch_values': index 42 outside of array bounds: -1...1 (IndexError)
+          from -e:1:in '<main>'
+  ```
+
 ## Stdlib compatibility issues
 
 * CGI library is removed from the default gems. Now we only provide `cgi/escape` for
@@ -446,6 +489,7 @@ A lot of work has gone into making Ractors more stable, performant, and usable.
 [Feature #20750]: https://bugs.ruby-lang.org/issues/20750
 [Feature #20884]: https://bugs.ruby-lang.org/issues/20884
 [Feature #20925]: https://bugs.ruby-lang.org/issues/20925
+[Bug #20968]:     https://bugs.ruby-lang.org/issues/20968
 [Feature #20971]: https://bugs.ruby-lang.org/issues/20971
 [Bug #20974]:     https://bugs.ruby-lang.org/issues/20974
 [Feature #21047]: https://bugs.ruby-lang.org/issues/21047
@@ -470,8 +514,10 @@ A lot of work has gone into making Ractors more stable, performant, and usable.
 [Feature #21390]: https://bugs.ruby-lang.org/issues/21390
 [Feature #21459]: https://bugs.ruby-lang.org/issues/21459
 [Feature #21527]: https://bugs.ruby-lang.org/issues/21527
+[Feature #21543]: https://bugs.ruby-lang.org/issues/21543
 [Feature #21550]: https://bugs.ruby-lang.org/issues/21550
 [Feature #21557]: https://bugs.ruby-lang.org/issues/21557
 [Bug #21654]:     https://bugs.ruby-lang.org/issues/21654
 [Feature #21678]: https://bugs.ruby-lang.org/issues/21678
+[Bug #21698]:     https://bugs.ruby-lang.org/issues/21698
 [Feature #21701]: https://bugs.ruby-lang.org/issues/21701

ext/socket/init.c

@@ -473,7 +473,7 @@ rsock_socket(int domain, int type, int proto)
 
 /* emulate blocking connect behavior on EINTR or non-blocking socket */
 static int
-wait_connectable(VALUE self, VALUE timeout)
+wait_connectable(VALUE self, VALUE timeout, const struct sockaddr *sockaddr, int len)
 {
     int sockerr;
     socklen_t sockerrlen;
@@ -514,7 +514,10 @@ wait_connectable(VALUE self, VALUE timeout)
     VALUE result = rb_io_wait(self, RB_INT2NUM(RUBY_IO_READABLE|RUBY_IO_WRITABLE), timeout);
 
     if (result == Qfalse) {
-        rb_raise(rb_eIOTimeoutError, "Connect timed out!");
+        VALUE rai = rsock_addrinfo_new((struct sockaddr *)sockaddr, len, PF_UNSPEC, 0, 0, Qnil, Qnil);
+        VALUE addr_str = rsock_addrinfo_inspect_sockaddr(rai);
+        VALUE message = rb_sprintf("user specified timeout for %" PRIsVALUE, addr_str);
+        rb_raise(rb_eIOTimeoutError, "%" PRIsVALUE, message);
     }
 
     int revents = RB_NUM2INT(result);
@@ -603,7 +606,7 @@ rsock_connect(VALUE self, const struct sockaddr *sockaddr, int len, int socks, V
 #ifdef EINPROGRESS
           case EINPROGRESS:
 #endif
-            return wait_connectable(self, timeout);
+            return wait_connectable(self, timeout, sockaddr, len);
         }
     }
     return status;

ext/socket/ipsocket.c

@@ -27,9 +27,19 @@ struct inetsock_arg
 };
 
 void
-rsock_raise_user_specified_timeout(void)
+rsock_raise_user_specified_timeout(struct addrinfo *ai, VALUE host, VALUE port)
 {
-    rb_raise(rb_eIOTimeoutError, "user specified timeout");
+    VALUE message;
+
+    if (ai && ai->ai_addr) {
+        VALUE rai = rsock_addrinfo_new((struct sockaddr *)ai->ai_addr, (socklen_t)ai->ai_addrlen, PF_UNSPEC, 0, 0, Qnil, Qnil);
+        VALUE addr_str = rsock_addrinfo_inspect_sockaddr(rai);
+        message = rb_sprintf("user specified timeout for %" PRIsVALUE, addr_str);
+    } else {
+        message = rb_sprintf("user specified timeout for %" PRIsVALUE " port %" PRIsVALUE, host, port);
+    }
+
+    rb_raise(rb_eIOTimeoutError, "%" PRIsVALUE, message);
 }
 
 static VALUE
@@ -149,7 +159,9 @@ init_inetsock_internal(VALUE v)
             } else {
                 VALUE elapsed = rb_funcall(current_clocktime(), '-', 1, starts_at);
                 timeout = rb_funcall(open_timeout, '-', 1, elapsed);
-                if (rb_funcall(timeout, '<', 1, INT2FIX(0)) == Qtrue) rsock_raise_user_specified_timeout();
+                if (rb_funcall(timeout, '<', 1, INT2FIX(0)) == Qtrue) {
+                    rsock_raise_user_specified_timeout(res, arg->remote.host, arg->remote.serv);
+                }
             }
 
             if (status >= 0) {
@@ -844,6 +856,10 @@ init_fast_fallback_inetsock_internal(VALUE v)
                     if (!NIL_P(open_timeout)) {
                         VALUE elapsed = rb_funcall(current_clocktime(), '-', 1, starts_at);
                         timeout = rb_funcall(open_timeout, '-', 1, elapsed);
+
+                        if (rb_funcall(timeout, '<', 1, INT2FIX(0)) == Qtrue) {
+                            rsock_raise_user_specified_timeout(NULL, arg->remote.host, arg->remote.serv);
+                        }
                     }
                     if (NIL_P(timeout)) {
                         if (!NIL_P(connect_timeout)) {
@@ -1180,7 +1196,9 @@ init_fast_fallback_inetsock_internal(VALUE v)
             }
         }
 
-        if (is_timeout_tv(user_specified_open_timeout_at, now)) rsock_raise_user_specified_timeout();
+        if (is_timeout_tv(user_specified_open_timeout_at, now)) {
+            rsock_raise_user_specified_timeout(NULL, arg->remote.host, arg->remote.serv);
+        }
 
         if (!any_addrinfos(&resolution_store)) {
             if (!in_progress_fds(arg->connection_attempt_fds_size) &&
@@ -1203,7 +1221,7 @@ init_fast_fallback_inetsock_internal(VALUE v)
                 resolution_store.is_all_finished) &&
                 (is_timeout_tv(user_specified_connect_timeout_at, now) ||
                 !in_progress_fds(arg->connection_attempt_fds_size))) {
-                rsock_raise_user_specified_timeout();
+                rsock_raise_user_specified_timeout(NULL, arg->remote.host, arg->remote.serv);
             }
         }
     }

ext/socket/lib/socket.rb

@@ -62,7 +62,7 @@ def connect_internal(local_addrinfo, timeout=nil) # :yields: socket
           break
         when :wait_writable
           sock.wait_writable(timeout) or
-            raise Errno::ETIMEDOUT, 'user specified timeout'
+            raise Errno::ETIMEDOUT, "user specified timeout for #{self.ip_address}:#{self.ip_port}"
         end while true
       else
         sock.connect(self)
@@ -905,7 +905,9 @@ def self.tcp_with_fast_fallback(host, port, local_host = nil, local_port = nil,
         end
       end
 
-      raise(IO::TimeoutError, 'user specified timeout') if expired?(now, user_specified_open_timeout_at)
+      if expired?(now, user_specified_open_timeout_at)
+        raise(IO::TimeoutError, "user specified timeout for #{host}:#{port}")
+      end
 
       if resolution_store.empty_addrinfos?
         if connecting_sockets.empty? && resolution_store.resolved_all_families?
@@ -918,7 +920,7 @@ def self.tcp_with_fast_fallback(host, port, local_host = nil, local_port = nil,
 
         if (expired?(now, user_specified_resolv_timeout_at) || resolution_store.resolved_all_families?) &&
            (expired?(now, user_specified_connect_timeout_at) || connecting_sockets.empty?)
-          raise IO::TimeoutError, 'user specified timeout'
+          raise(IO::TimeoutError, "user specified timeout for #{host}:#{port}")
         end
       end
     end

ext/socket/raddrinfo.c

@@ -597,7 +597,15 @@ rb_getaddrinfo(const char *hostp, const char *portp, const struct addrinfo *hint
 
     if (need_free) free_getaddrinfo_arg(arg);
 
-    if (timedout) rsock_raise_user_specified_timeout();
+    if (timedout) {
+        if (arg->ai) {
+            rsock_raise_user_specified_timeout(arg->ai, Qnil, Qnil);
+        } else {
+            VALUE host = rb_str_new_cstr(hostp);
+            VALUE port = rb_str_new_cstr(portp);
+            rsock_raise_user_specified_timeout(NULL, host, port);
+        }
+    }
 
     // If the current thread is interrupted by asynchronous exception, the following raises the exception.
     // But if the current thread is interrupted by timer thread, the following returns; we need to manually retry.

ext/socket/rubysocket.h

@@ -454,7 +454,7 @@ void free_fast_fallback_getaddrinfo_shared(struct fast_fallback_getaddrinfo_shar
 #endif
 
 unsigned int rsock_value_timeout_to_msec(VALUE);
-NORETURN(void rsock_raise_user_specified_timeout(void));
+NORETURN(void rsock_raise_user_specified_timeout(struct addrinfo *ai, VALUE host, VALUE port));
 
 void rsock_init_basicsocket(void);
 void rsock_init_ipsocket(void);