[ruby-core:112134] [Ruby master Bug#19392] Endless method vs and/or

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/
 ______________________________________________
 ruby-core mailing list -- [e-mail]
 To unsubscribe send an email to [e-mail]
 ruby-core info -- https://ml.ruby-lang.org/mailman3/postorius/lists/ruby-core.ml.ruby-lang.org/