2021-12-25 17:11:13 +03:00
|
|
|
# NEWS for Ruby 3.2.0
|
2020-01-15 06:42:47 +03:00
|
|
|
|
2021-12-15 19:24:31 +03:00
|
|
|
This document is a list of user-visible feature changes
|
2021-12-25 17:11:13 +03:00
|
|
|
since the **3.1.0** release, except for bug fixes.
|
2020-01-15 06:42:47 +03:00
|
|
|
|
2020-12-22 22:27:38 +03:00
|
|
|
Note that each entry is kept to a minimum, see links for details.
|
2020-01-15 06:42:47 +03:00
|
|
|
|
2020-01-18 11:46:52 +03:00
|
|
|
## Language changes
|
Evaluate multiple assignment left hand side before right hand side
In regular assignment, Ruby evaluates the left hand side before
the right hand side. For example:
```ruby
foo[0] = bar
```
Calls `foo`, then `bar`, then `[]=` on the result of `foo`.
Previously, multiple assignment didn't work this way. If you did:
```ruby
abc.def, foo[0] = bar, baz
```
Ruby would previously call `bar`, then `baz`, then `abc`, then
`def=` on the result of `abc`, then `foo`, then `[]=` on the
result of `foo`.
This change makes multiple assignment similar to single assignment,
changing the evaluation order of the above multiple assignment code
to calling `abc`, then `foo`, then `bar`, then `baz`, then `def=` on
the result of `abc`, then `[]=` on the result of `foo`.
Implementing this is challenging with the stack-based virtual machine.
We need to keep track of all of the left hand side attribute setter
receivers and setter arguments, and then keep track of the stack level
while handling the assignment processing, so we can issue the
appropriate topn instructions to get the receiver. Here's an example
of how the multiple assignment is executed, showing the stack and
instructions:
```
self # putself
abc # send
abc, self # putself
abc, foo # send
abc, foo, 0 # putobject 0
abc, foo, 0, [bar, baz] # evaluate RHS
abc, foo, 0, [bar, baz], baz, bar # expandarray
abc, foo, 0, [bar, baz], baz, bar, abc # topn 5
abc, foo, 0, [bar, baz], baz, abc, bar # swap
abc, foo, 0, [bar, baz], baz, def= # send
abc, foo, 0, [bar, baz], baz # pop
abc, foo, 0, [bar, baz], baz, foo # topn 3
abc, foo, 0, [bar, baz], baz, foo, 0 # topn 3
abc, foo, 0, [bar, baz], baz, foo, 0, baz # topn 2
abc, foo, 0, [bar, baz], baz, []= # send
abc, foo, 0, [bar, baz], baz # pop
abc, foo, 0, [bar, baz] # pop
[bar, baz], foo, 0, [bar, baz] # setn 3
[bar, baz], foo, 0 # pop
[bar, baz], foo # pop
[bar, baz] # pop
```
As multiple assignment must deal with splats, post args, and any level
of nesting, it gets quite a bit more complex than this in non-trivial
cases. To handle this, struct masgn_state is added to keep
track of the overall state of the mass assignment, which stores a linked
list of struct masgn_attrasgn, one for each assigned attribute.
This adds a new optimization that replaces a topn 1/pop instruction
combination with a single swap instruction for multiple assignment
to non-aref attributes.
This new approach isn't compatible with one of the optimizations
previously used, in the case where the multiple assignment return value
was not needed, there was no lhs splat, and one of the left hand side
used an attribute setter. This removes that optimization. Removing
the optimization allowed for removing the POP_ELEMENT and adjust_stack
functions.
This adds a benchmark to measure how much slower multiple
assignment is with the correct evaluation order.
This benchmark shows:
* 4-9% decrease for attribute sets
* 14-23% decrease for array member sets
* Basically same speed for local variable sets
Importantly, it shows no significant difference between the popped
(where return value of the multiple assignment is not needed) and
!popped (where return value of the multiple assignment is needed)
cases for attribute and array member sets. This indicates the
previous optimization, which was dropped in the evaluation
order fix and only affected the popped case, is not important to
performance.
Fixes [Bug #4443]
2021-04-21 20:49:19 +03:00
|
|
|
|
Add support for anonymous rest and keyword rest argument forwarding
This allows for the following syntax:
```ruby
def foo(*)
bar(*)
end
def baz(**)
quux(**)
end
```
This is a natural addition after the introduction of anonymous
block forwarding. Anonymous rest and keyword rest arguments were
already supported in method parameters, this just allows them to
be used as arguments to other methods. The same advantages of
anonymous block forwarding apply to rest and keyword rest argument
forwarding.
This has some minor changes to #parameters output. Now, instead
of `[:rest], [:keyrest]`, you get `[:rest, :*], [:keyrest, :**]`.
These were already used for `...` forwarding, so I think it makes
it more consistent to include them in other cases. If we want to
use `[:rest], [:keyrest]` in both cases, that is also possible.
I don't think the previous behavior of `[:rest], [:keyrest]` in
the non-... case and `[:rest, :*], [:keyrest, :**]` in the ...
case makes sense, but if we did want that behavior, we'll have to
make more substantial changes, such as using a different ID in the
... forwarding case.
Implements [Feature #18351]
2021-11-19 20:38:22 +03:00
|
|
|
* Anonymous rest and keyword rest arguments can now be passed as
|
|
|
|
|
arguments, instead of just used in method parameters.
|
|
|
|
|
[[Feature #18351]]
|
|
|
|
|
|
|
|
|
|
```ruby
|
|
|
|
|
def foo(*)
|
|
|
|
|
bar(*)
|
|
|
|
|
end
|
|
|
|
|
def baz(**)
|
|
|
|
|
quux(**)
|
|
|
|
|
end
|
|
|
|
|
```
|
|
|
|
|
|
Fix constant assignment evaluation order
Previously, the right hand side was always evaluated before the
left hand side for constant assignments. For the following:
```ruby
lhs::C = rhs
```
rhs was evaluated before lhs, which is inconsistant with attribute
assignment (lhs.m = rhs), and apparently also does not conform to
JIS 3017:2013 11.4.2.2.3.
Fix this by changing evaluation order. Previously, the above
compiled to:
```
0000 putself ( 1)[Li]
0001 opt_send_without_block <calldata!mid:rhs, argc:0, FCALL|VCALL|ARGS_SIMPLE>
0003 dup
0004 putself
0005 opt_send_without_block <calldata!mid:lhs, argc:0, FCALL|VCALL|ARGS_SIMPLE>
0007 setconstant :C
0009 leave
```
After this change:
```
0000 putself ( 1)[Li]
0001 opt_send_without_block <calldata!mid:lhs, argc:0, FCALL|VCALL|ARGS_SIMPLE>
0003 putself
0004 opt_send_without_block <calldata!mid:rhs, argc:0, FCALL|VCALL|ARGS_SIMPLE>
0006 swap
0007 topn 1
0009 swap
0010 setconstant :C
0012 leave
```
Note that if expr is not a module/class, then a TypeError is not
raised until after the evaluation of rhs. This is because that
error is raised by setconstant. If we wanted to raise TypeError
before evaluation of rhs, we would have to add a VM instruction
for calling vm_check_if_namespace.
Changing assignment order for single assignments caused problems
in the multiple assignment code, revealing that the issue also
affected multiple assignment. Fix the multiple assignment code
so left-to-right evaluation also works for constant assignments.
Do some refactoring of the multiple assignment code to reduce
duplication after adding support for constants. Rename struct
masgn_attrasgn to masgn_lhs_node, since it now handles both
constants and attributes. Add add_masgn_lhs_node static function
for adding data for lhs attribute and constant setting.
Fixes [Bug #15928]
2021-05-01 02:01:27 +03:00
|
|
|
* Constant assignment evaluation order for constants set on explicit
|
|
|
|
|
objects has been made consistent with single attribute assignment
|
|
|
|
|
evaluation order. With this code:
|
|
|
|
|
|
|
|
|
|
```ruby
|
|
|
|
|
foo::BAR = baz
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
`foo` is now called before `baz`. Similarly, for multiple assignment
|
|
|
|
|
to constants, left-to-right evaluation order is used. With this
|
|
|
|
|
code:
|
|
|
|
|
|
|
|
|
|
```ruby
|
|
|
|
|
foo1::BAR1, foo2::BAR2 = baz1, baz2
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
The following evaluation order is now used:
|
|
|
|
|
|
|
|
|
|
1. `foo1`
|
|
|
|
|
2. `foo2`
|
|
|
|
|
3. `baz1`
|
|
|
|
|
4. `baz2`
|
|
|
|
|
|
|
|
|
|
[[Bug #15928]]
|
|
|
|
|
|
2020-01-18 11:46:52 +03:00
|
|
|
## Command line options
|
2020-01-15 06:42:47 +03:00
|
|
|
|
2020-03-03 11:37:51 +03:00
|
|
|
## Core classes updates
|
|
|
|
|
|
2021-12-15 19:24:31 +03:00
|
|
|
Note: We're only listing outstanding class updates.
|
2020-01-15 06:42:47 +03:00
|
|
|
|
2021-12-28 01:41:43 +03:00
|
|
|
* Hash
|
|
|
|
|
* Hash#shift now always returns nil if the hash is
|
|
|
|
|
empty, instead of returning the default value or
|
|
|
|
|
calling the default proc. [[Bug #16908]]
|
|
|
|
|
|
2022-01-05 10:58:23 +03:00
|
|
|
* Module
|
|
|
|
|
* Module.used_refinements has been added. [[Feature #14332]]
|
2022-01-05 11:47:29 +03:00
|
|
|
* Module#refinements has been added. [[Feature #12737]]
|
2021-05-22 13:04:01 +03:00
|
|
|
* Module#const_added has been added. [[Feature #17881]]
|
2022-01-05 11:47:29 +03:00
|
|
|
|
2022-01-13 11:45:25 +03:00
|
|
|
* Proc
|
|
|
|
|
* Proc#dup returns an instance of subclass. [[Bug #17545]]
|
|
|
|
|
|
2022-01-05 11:47:29 +03:00
|
|
|
* Refinement
|
|
|
|
|
* Refinement#refined_class has been added. [[Feature #12737]]
|
2022-01-05 10:58:23 +03:00
|
|
|
|
2022-01-29 11:32:38 +03:00
|
|
|
* Struct
|
|
|
|
|
* A Struct class can also be initialized with keyboard arguments
|
|
|
|
|
without `keyword_init: true` on `Struct.new` [[Feature #16806]]
|
|
|
|
|
|
2020-03-03 11:37:51 +03:00
|
|
|
## Stdlib updates
|
|
|
|
|
|
2021-12-05 13:08:25 +03:00
|
|
|
* The following default gem are updated.
|
2021-12-27 04:48:03 +03:00
|
|
|
* RubyGems 3.4.0.dev
|
2022-01-24 04:57:23 +03:00
|
|
|
* bigdecimal 3.1.2
|
2021-12-27 04:48:03 +03:00
|
|
|
* bundler 2.4.0.dev
|
2022-01-02 09:06:11 +03:00
|
|
|
* etc 1.4.0
|
2021-12-29 04:03:36 +03:00
|
|
|
* io-console 0.5.11
|
2022-01-02 05:29:48 +03:00
|
|
|
* reline 0.3.1
|
2021-12-05 13:08:25 +03:00
|
|
|
* The following bundled gems are updated.
|
2022-01-06 10:02:37 +03:00
|
|
|
* net-imap 0.2.3
|
2021-12-29 10:02:15 +03:00
|
|
|
* typeprof 0.21.2
|
2021-12-05 13:08:25 +03:00
|
|
|
* The following default gems are now bundled gems.
|
2020-01-15 06:42:47 +03:00
|
|
|
|
2020-03-03 11:37:51 +03:00
|
|
|
## Compatibility issues
|
|
|
|
|
|
2021-12-15 19:24:31 +03:00
|
|
|
Note: Excluding feature bug fixes.
|
2020-01-15 06:42:47 +03:00
|
|
|
|
2022-01-06 05:20:55 +03:00
|
|
|
### Removed constants
|
2021-12-31 17:59:50 +03:00
|
|
|
|
2022-01-07 03:44:08 +03:00
|
|
|
The following deprecated constants are removed.
|
2022-01-02 09:05:02 +03:00
|
|
|
|
2022-01-25 17:10:20 +03:00
|
|
|
* `Fixnum` and `Bignum` [[Feature #12005]]
|
2022-01-05 12:27:16 +03:00
|
|
|
* `Random::DEFAULT` [[Feature #17351]]
|
2022-01-02 09:05:02 +03:00
|
|
|
* `Struct::Group`
|
|
|
|
|
* `Struct::Passwd`
|
|
|
|
|
|
2022-01-06 05:20:55 +03:00
|
|
|
### Removed methods
|
|
|
|
|
|
2021-12-31 17:59:50 +03:00
|
|
|
The following deprecated methods are removed.
|
|
|
|
|
|
2022-01-05 12:27:16 +03:00
|
|
|
* `Dir.exists?` [[Feature #17391]]
|
|
|
|
|
* `File.exists?` [[Feature #17391]]
|
2022-01-05 12:18:43 +03:00
|
|
|
* `Kernel#=~` [[Feature #15231]]
|
2022-01-06 05:32:27 +03:00
|
|
|
* `Kernel#taint`, `Kernel#untaint`, `Kernel#tainted?`
|
|
|
|
|
[[Feature #16131]]
|
|
|
|
|
* `Kernel#trust`, `Kernel#untrust`, `Kernel#untrusted?`
|
|
|
|
|
[[Feature #16131]]
|
2021-12-31 17:59:50 +03:00
|
|
|
|
2020-08-24 09:38:03 +03:00
|
|
|
## Stdlib compatibility issues
|
2020-06-18 15:11:19 +03:00
|
|
|
|
2020-01-18 11:46:52 +03:00
|
|
|
## C API updates
|
2020-01-15 06:42:47 +03:00
|
|
|
|
2021-12-31 17:59:04 +03:00
|
|
|
### Removed C APIs
|
|
|
|
|
|
|
|
|
|
The following deprecated APIs are removed.
|
|
|
|
|
|
|
|
|
|
* `rb_cData` variable.
|
2022-01-06 05:32:27 +03:00
|
|
|
* "taintedness" and "trustedness" functions. [[Feature #16131]]
|
2021-12-31 17:59:04 +03:00
|
|
|
|
2020-01-18 11:46:52 +03:00
|
|
|
## Implementation improvements
|
2020-01-15 06:42:47 +03:00
|
|
|
|
2021-12-14 03:08:01 +03:00
|
|
|
## JIT
|
2020-06-26 10:54:05 +03:00
|
|
|
|
2021-12-14 03:08:01 +03:00
|
|
|
### MJIT
|
|
|
|
|
|
2021-10-20 22:51:07 +03:00
|
|
|
### YJIT: New experimental in-process JIT compiler
|
|
|
|
|
|
2020-11-10 20:15:57 +03:00
|
|
|
## Static analysis
|
2020-10-20 07:16:19 +03:00
|
|
|
|
|
|
|
|
### RBS
|
2020-09-25 11:08:39 +03:00
|
|
|
|
2020-10-20 07:16:19 +03:00
|
|
|
### TypeProf
|
|
|
|
|
|
2021-10-20 04:18:54 +03:00
|
|
|
## Debugger
|
|
|
|
|
|
2021-10-20 05:05:05 +03:00
|
|
|
## error_highlight
|
|
|
|
|
|
2021-12-25 11:05:39 +03:00
|
|
|
## IRB Autocomplete and Document Display
|
|
|
|
|
|
2020-01-18 11:46:52 +03:00
|
|
|
## Miscellaneous changes
|
Add support for anonymous rest and keyword rest argument forwarding
This allows for the following syntax:
```ruby
def foo(*)
bar(*)
end
def baz(**)
quux(**)
end
```
This is a natural addition after the introduction of anonymous
block forwarding. Anonymous rest and keyword rest arguments were
already supported in method parameters, this just allows them to
be used as arguments to other methods. The same advantages of
anonymous block forwarding apply to rest and keyword rest argument
forwarding.
This has some minor changes to #parameters output. Now, instead
of `[:rest], [:keyrest]`, you get `[:rest, :*], [:keyrest, :**]`.
These were already used for `...` forwarding, so I think it makes
it more consistent to include them in other cases. If we want to
use `[:rest], [:keyrest]` in both cases, that is also possible.
I don't think the previous behavior of `[:rest], [:keyrest]` in
the non-... case and `[:rest, :*], [:keyrest, :**]` in the ...
case makes sense, but if we did want that behavior, we'll have to
make more substantial changes, such as using a different ID in the
... forwarding case.
Implements [Feature #18351]
2021-11-19 20:38:22 +03:00
|
|
|
|
2022-01-25 17:10:20 +03:00
|
|
|
[Feature #12005]: https://bugs.ruby-lang.org/issues/12005
|
2022-01-06 17:49:27 +03:00
|
|
|
[Feature #12737]: https://bugs.ruby-lang.org/issues/12737
|
|
|
|
|
[Feature #14332]: https://bugs.ruby-lang.org/issues/14332
|
2022-01-05 12:18:43 +03:00
|
|
|
[Feature #15231]: https://bugs.ruby-lang.org/issues/15231
|
Fix constant assignment evaluation order
Previously, the right hand side was always evaluated before the
left hand side for constant assignments. For the following:
```ruby
lhs::C = rhs
```
rhs was evaluated before lhs, which is inconsistant with attribute
assignment (lhs.m = rhs), and apparently also does not conform to
JIS 3017:2013 11.4.2.2.3.
Fix this by changing evaluation order. Previously, the above
compiled to:
```
0000 putself ( 1)[Li]
0001 opt_send_without_block <calldata!mid:rhs, argc:0, FCALL|VCALL|ARGS_SIMPLE>
0003 dup
0004 putself
0005 opt_send_without_block <calldata!mid:lhs, argc:0, FCALL|VCALL|ARGS_SIMPLE>
0007 setconstant :C
0009 leave
```
After this change:
```
0000 putself ( 1)[Li]
0001 opt_send_without_block <calldata!mid:lhs, argc:0, FCALL|VCALL|ARGS_SIMPLE>
0003 putself
0004 opt_send_without_block <calldata!mid:rhs, argc:0, FCALL|VCALL|ARGS_SIMPLE>
0006 swap
0007 topn 1
0009 swap
0010 setconstant :C
0012 leave
```
Note that if expr is not a module/class, then a TypeError is not
raised until after the evaluation of rhs. This is because that
error is raised by setconstant. If we wanted to raise TypeError
before evaluation of rhs, we would have to add a VM instruction
for calling vm_check_if_namespace.
Changing assignment order for single assignments caused problems
in the multiple assignment code, revealing that the issue also
affected multiple assignment. Fix the multiple assignment code
so left-to-right evaluation also works for constant assignments.
Do some refactoring of the multiple assignment code to reduce
duplication after adding support for constants. Rename struct
masgn_attrasgn to masgn_lhs_node, since it now handles both
constants and attributes. Add add_masgn_lhs_node static function
for adding data for lhs attribute and constant setting.
Fixes [Bug #15928]
2021-05-01 02:01:27 +03:00
|
|
|
[Bug #15928]: https://bugs.ruby-lang.org/issues/15928
|
2022-01-06 05:32:27 +03:00
|
|
|
[Feature #16131]: https://bugs.ruby-lang.org/issues/16131
|
2022-01-29 11:32:38 +03:00
|
|
|
[Feature #16806]: https://bugs.ruby-lang.org/issues/16806
|
2021-12-28 01:41:43 +03:00
|
|
|
[Bug #16908]: https://bugs.ruby-lang.org/issues/16908
|
2022-01-05 12:27:16 +03:00
|
|
|
[Feature #17351]: https://bugs.ruby-lang.org/issues/17351
|
|
|
|
|
[Feature #17391]: https://bugs.ruby-lang.org/issues/17391
|
2022-01-13 11:45:25 +03:00
|
|
|
[Bug #17545]: https://bugs.ruby-lang.org/issues/17545
|
2022-01-18 16:57:21 +03:00
|
|
|
[Feature #17881]: https://bugs.ruby-lang.org/issues/17881
|
Add support for anonymous rest and keyword rest argument forwarding
This allows for the following syntax:
```ruby
def foo(*)
bar(*)
end
def baz(**)
quux(**)
end
```
This is a natural addition after the introduction of anonymous
block forwarding. Anonymous rest and keyword rest arguments were
already supported in method parameters, this just allows them to
be used as arguments to other methods. The same advantages of
anonymous block forwarding apply to rest and keyword rest argument
forwarding.
This has some minor changes to #parameters output. Now, instead
of `[:rest], [:keyrest]`, you get `[:rest, :*], [:keyrest, :**]`.
These were already used for `...` forwarding, so I think it makes
it more consistent to include them in other cases. If we want to
use `[:rest], [:keyrest]` in both cases, that is also possible.
I don't think the previous behavior of `[:rest], [:keyrest]` in
the non-... case and `[:rest, :*], [:keyrest, :**]` in the ...
case makes sense, but if we did want that behavior, we'll have to
make more substantial changes, such as using a different ID in the
... forwarding case.
Implements [Feature #18351]
2021-11-19 20:38:22 +03:00
|
|
|
[Feature #18351]: https://bugs.ruby-lang.org/issues/18351
|
