31 Jan
2023
31 Jan
'23
7:52 a.m.
Issue #19392 has been updated by zverok (Victor Shepelev).
Status changed from Rejected to Open
@nobu Sorry, can we talk about it a bit more?..
I am not an expert in parser's internals, so I _can_ believe that it is 100%
impossible to solve, but is it?..
From developer's experience point of view:
* There is a high possibility of using `def foo = statement or statement`, it is quite
regularly used idiom for shortcutting and validations;
* Depending on the second part of such expression, the wrong behavior might be noticed
very late;
* There are no useful consequences (that I can think of) for breaking the one-line method
body on `and`/`or`, so it can't be justified by "it doesn't work this way,
because it actually does this interesting thing!"
Therefore it definitely **perceives like a bug** and a harmless one, not just
"useless trivia" kind.
Moreover:
* One-line method definitions aren't any expressions. They introduce a new scope, for
example, and having a scope suddenly ending mid-line on _operator_ (and not at least on
`;`) is behavior that screams "bug", even if it can be explained in "it is
internal precedence" terms:
```ruby
def test = x = 5 and puts x
# in `<main>': undefined local variable or method `x' for main:Object
(NameError)
```
* Again, I am not a Ruby internal expert (though if there is no other choice, I can take
on studying this problem), but I have a hunch that it isn't impossible to introduce a
simple rule "endless method's definition ends on `;` or `\n`, and nothing
else". That's the user expectation, anyway.
----------------------------------------
Bug #19392: Endless method vs and/or
https://bugs.ruby-lang.org/issues/19392#change-101571
* Author: zverok (Victor Shepelev)
* Status: Open
* Priority: Normal
* Backport: 2.7: DONTNEED, 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN
----------------------------------------
[Discovered](https://twitter.com/lucianghinda/status/1617783952353406977) by Lucian
Ghinda:
```ruby
def test = puts("foo") and puts("bar")
# prints "bar" immediately
test
# prints "foo"
```
It seems that it is a parser error, right?..
```ruby
RubyVM::AbstractSyntaxTree.parse('def test = puts("foo") and
puts("bar")')
# =>
# (SCOPE@1:0-1:38
# tbl: []
# args: nil
# body:
# (AND@1:0-1:38
# (DEFN@1:0-1:22
# mid: :test
# body:
# (SCOPE@1:0-1:22
# tbl: []
# args:
# (ARGS@1:0-1:8 pre_num: 0 pre_init: nil opt: nil first_post: nil post_num: 0
post_init: nil rest: nil kw: nil kwrest: nil block: nil)
# body: (FCALL@1:11-1:22 :puts (LIST@1:16-1:21 (STR@1:16-1:21 "foo")
nil))))
# (FCALL@1:27-1:38 :puts (LIST@1:32-1:37 (STR@1:32-1:37 "bar") nil))))
```
E.g. it is parsed as
```ruby
(def test = puts("foo")) and (puts("bar"))
```
...which is hardly intentional or have any practical use. The rightly parsed code in this
case _can_ have practical use, like
```ruby
def write(data) = File.write(@filename, data) == data.size or raise "Something went
wrong"
```
--
https://bugs.ruby-lang.org/