Issue #19392 has been updated by austin (Austin Ziegler). Note that this does not happen with `&&` / `||`, so it’s a binding precedence issue. ---------------------------------------- Bug #19392: Endless method vs and/or https://bugs.ruby-lang.org/issues/19392#change-101555 * 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/

Issue #19392 has been updated by nobu (Nobuyoshi Nakada). Status changed from Open to Rejected This precedence is needed to allow: ```ruby public def test = puts("foo") ``` ---------------------------------------- Bug #19392: Endless method vs and/or https://bugs.ruby-lang.org/issues/19392#change-101564 * Author: zverok (Victor Shepelev) * Status: Rejected * 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/

Issue #19392 has been updated by nobu (Nobuyoshi Nakada). zverok (Victor Shepelev) wrote in #note-4: It depends on how you define "expressions". At least in Ruby's terms, any method definition can be an argument of other method calls. ```ruby public def test1(x) = x = 5 public def test2(x) x = 5 end ``` In the above examples, both methods return the method ID and the result will be passed to the method `public`. To utilize this, `def` returns the ID since 2.3. ---------------------------------------- Bug #19392: Endless method vs and/or https://bugs.ruby-lang.org/issues/19392#change-101594 * 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/

Issue #19392 has been updated by zverok (Victor Shepelev). `and` is actually not alone. The code like this is also parsed not the way one would intuitively expect: ```ruby def save = File.write(name, self.to_yaml) unless invalid? ``` Actual parsing is this: ```ruby (def save = File.write(name, self.to_yaml)) unless invalid? ``` I believe that combining postfix `if`/`unless` with one-line methods is extremely possible, while intention to conditionally define methods with postfix condition is much less so. In general, I believe that ```ruby def method expression end ``` and ```ruby def method = expression ``` should be equivalent as long as it is humanly possible, because the simplification of one-expression method to endless one is what many codebases would try to do, especially for simple utility classes. And if they can't be made equivalent (due to some parser complexities), the only other acceptable behavior is an error or at least warning (though the latter is much less desirable), not a silent change of semantics. ---------------------------------------- Bug #19392: Endless method vs and/or https://bugs.ruby-lang.org/issues/19392#change-102110 * 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/

Issue #19392 has been updated by matz (Yukihiro Matsumoto). Status changed from Feedback to Closed Analogous to `a = b and c` parsed as `(a = b) and c`, `def a = b and c` should be parsed as `(def a = b) and c`. Considering the fact no one really want to write `(def a = b) and c`, it may be better to cause a warning in the future. I understand there's some confusion regarding the precedence of `and`, `or` operators, but if we change the precedence it may break a huge amount of existing code. Matz. ---------------------------------------- Bug #19392: Endless method vs and/or https://bugs.ruby-lang.org/issues/19392#change-102834 * Author: zverok (Victor Shepelev) * Status: Closed * 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/

Issue #19392 has been updated by yui-knk (Kaneko Yuichiro). JFYI: https://github.com/ruby/ruby/pull/8054 doesn't change the precedence globally, however `def test = puts("foo") or puts("bar")` is interrupted as `def test = (puts("foo") or puts("bar"))`. ---------------------------------------- Bug #19392: Endless method vs and/or https://bugs.ruby-lang.org/issues/19392#change-103799 * Author: zverok (Victor Shepelev) * Status: Closed * 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/

Issue #19392 has been updated by zverok (Victor Shepelev). Subject changed from Endless method vs and/or to Endless method and parsing priorities Description updated Updated the description to underline the nature of the problem better. ---------------------------------------- Bug #19392: Endless method and parsing priorities https://bugs.ruby-lang.org/issues/19392#change-105483 * Author: zverok (Victor Shepelev) * Status: Open * Priority: Normal * Backport: 2.7: DONTNEED, 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN ---------------------------------------- **Initial description** [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" ``` **Additional cases of what seems to be the same problem** ```ruby def save = File.write(name, self.to_yaml) unless invalid? # Parsed as: (def save = File.write(name, self.to_yaml)) unless invalid? ``` ...which makes it very hard for the users to diagnose the real reason, see #19731 ```ruby def initialize(a, b) = @a, b = a, b # syntax error, unexpected ',', expecting end-of-input (SyntaxError) # def initialize(a, b) = @a, b = a, b # ^ # Again, parsed as (def initialize(a, b) = @a), b = a, b ``` While this one is at least diagnosed early, in pathological cases, it might lead to very subtle bugs: ```ruby private def start = @operation, @conversion = :print, :to_s ``` This code doesn't throw a syntax error, but its effect is very far from expected. Again, it is parsed as ```ruby private( (def start = @operation), @conversion = :print, :to_s ) ``` ...and ends up in: * defining a private method `start` * making private methods `:print` and `:to_s` -- https://bugs.ruby-lang.org/

Issue #19392 has been updated by zverok (Victor Shepelev). @mame I understand I might sound annoying, but I believe there is **absolutely nothing natural** about this behavior for the users (as is shown by the confusion of _everybody_ who is met with this behavior in real codebases: it is frequently impossible even to guess where the problem is coming from). While we reused `=` sign to designate one-line methods, it is _not_ "like any other assignment": 1. It doesn't assign a value, actually, that can be then operated by value rules; 2. It can't be used in method bodies (or, it can, but the result wouldn't follow the logic of other assignments, but follow the logic of method definitions, affecting the outer scope); 3. It doesn't evaluate the expression on the right but "stores" it as a method body. The expectation of _every_ sane usage of endless methods is that "I have a short and expressive method body, I want to put it in one line, it should just work," i.e., that whatever it would be: ```ruby def foo(args) expression end ``` and ```ruby def foo(args) = expression ``` would be equivalent in as many situations as possible. While some "this can't be parsed at all" situations might be accepted, "it is parsed successfully, but the scope changes in the middle of what looks like a single expression" would never ever be "natural." The most annoying and confusing thing is "trailing `if`" because it is an incredibly widespread statement for short-and-expressive code. I understand the complexity of the parser development (and I can even assume that fixing the problem is downright impossible, though I hope it is not so). Still, I believe that with current behavior being preserved, **the feature would be forever considered "buggy and undercooked" and will never see wide adoption**, indirectly affecting the reputation of the language. **Can we please have one more round of discussion, even if after 3.3 release?** I am ready to try to contribute as much as possible, from preparing a presentation to give at the developer meeting with more detailed argumentation to trying to look at the parser myself. Unfortunately, I am not proficient in this part of Ruby code, but I can try; though, to invest a significant amount of time into this attempt, I would like to at least have an agreement on the fact that if the fix is possible, it would be considered. ---------------------------------------- Bug #19392: Endless method and parsing priorities https://bugs.ruby-lang.org/issues/19392#change-105577 * Author: zverok (Victor Shepelev) * Status: Closed * Priority: Normal * Backport: 2.7: DONTNEED, 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN ---------------------------------------- **Initial description** [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" ``` **Additional cases of what seems to be the same problem** ```ruby def save = File.write(name, self.to_yaml) unless invalid? # Parsed as: (def save = File.write(name, self.to_yaml)) unless invalid? ``` ...which makes it very hard for the users to diagnose the real reason, see #19731 ```ruby def initialize(a, b) = @a, b = a, b # syntax error, unexpected ',', expecting end-of-input (SyntaxError) # def initialize(a, b) = @a, b = a, b # ^ # Again, parsed as (def initialize(a, b) = @a), b = a, b ``` While this one is at least diagnosed early, in pathological cases, it might lead to very subtle bugs: ```ruby private def start = @operation, @conversion = :print, :to_s ``` This code doesn't throw a syntax error, but its effect is very far from expected. Again, it is parsed as ```ruby private( (def start = @operation), @conversion = :print, :to_s ) ``` ...and ends up in: * defining a private method `start` * making private methods `:print` and `:to_s` -- https://bugs.ruby-lang.org/

Issue #19392 has been updated by Eregon (Benoit Daloze). `def =` is clearly more about `def` than `=`. It is not an assignment, as clearly said by other just before this message. By that reasoning, `def m; a = b and c; end` should be `(def m; a = b) and (c; end)` then? (if the most important thing is that `and` is lower precedence than everything else no matter the context) `def` is stronger than `=` and `and`, that is very intuitive and simple. The same for `module`, `class`, they are scope-changing keywords. It makes no sense that `=` and `and` would be stronger than a scope-changing keyword, from a usage point of view. I think either this should be fixed or endless methods should be removed because hopelessly broken and uninintuitve. Of course we cannot remove them for compatibility so let's fix this to be like the overwhelming majority of Rubyists expect? ---------------------------------------- Bug #19392: Endless method and parsing priorities https://bugs.ruby-lang.org/issues/19392#change-105600 * Author: zverok (Victor Shepelev) * Status: Closed * Priority: Normal * Backport: 2.7: DONTNEED, 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN ---------------------------------------- **Initial description** [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" ``` **Additional cases of what seems to be the same problem** ```ruby def save = File.write(name, self.to_yaml) unless invalid? # Parsed as: (def save = File.write(name, self.to_yaml)) unless invalid? ``` ...which makes it very hard for the users to diagnose the real reason, see #19731 ```ruby def initialize(a, b) = @a, b = a, b # syntax error, unexpected ',', expecting end-of-input (SyntaxError) # def initialize(a, b) = @a, b = a, b # ^ # Again, parsed as (def initialize(a, b) = @a), b = a, b ``` While this one is at least diagnosed early, in pathological cases, it might lead to very subtle bugs: ```ruby private def start = @operation, @conversion = :print, :to_s ``` This code doesn't throw a syntax error, but its effect is very far from expected. Again, it is parsed as ```ruby private( (def start = @operation), @conversion = :print, :to_s ) ``` ...and ends up in: * defining a private method `start` * making private methods `:print` and `:to_s` -- https://bugs.ruby-lang.org/

Issue #19392 has been updated by duerst (Martin Dürst). I agree with others that there's not much (if anything) natural about this. In `def a = b and c`, the most important thing that virtually every Ruby programmer will see is `def`. To formalize this, we can think about a special `def=` operator. This `def=` operator has lower precedence than `and` or `if` or `unless`,... As a result, `def a = b and c` is interpreted as `def a = (b and c)`, which is easier to understand and more useful (because it is the more frequent usecase). Parsing this so that `def=` has lower precedence may not exactly be easy. But the Ruby parser goes through many contortions to make Ruby a language useful for human programmers, with very little concern for 'parsing difficulty'.[1] It would be weird if we gave up in this case because of 'parser difficulty'. `def=` has the huge advantage that `def` is prefix, which is much easier to handle in parsers that an infix or postfix operator. [1] The opposite of this is Pascal and other languages created by Niklaus Wirth. Wirths main goal when designing a language was to make the compiler easy to implement. ---------------------------------------- Bug #19392: Endless method and parsing priorities https://bugs.ruby-lang.org/issues/19392#change-105604 * Author: zverok (Victor Shepelev) * Status: Closed * Priority: Normal * Backport: 2.7: DONTNEED, 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN ---------------------------------------- **Initial description** [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" ``` **Additional cases of what seems to be the same problem** ```ruby def save = File.write(name, self.to_yaml) unless invalid? # Parsed as: (def save = File.write(name, self.to_yaml)) unless invalid? ``` ...which makes it very hard for the users to diagnose the real reason, see #19731 ```ruby def initialize(a, b) = @a, b = a, b # syntax error, unexpected ',', expecting end-of-input (SyntaxError) # def initialize(a, b) = @a, b = a, b # ^ # Again, parsed as (def initialize(a, b) = @a), b = a, b ``` While this one is at least diagnosed early, in pathological cases, it might lead to very subtle bugs: ```ruby private def start = @operation, @conversion = :print, :to_s ``` This code doesn't throw a syntax error, but its effect is very far from expected. Again, it is parsed as ```ruby private( (def start = @operation), @conversion = :print, :to_s ) ``` ...and ends up in: * defining a private method `start` * making private methods `:print` and `:to_s` -- https://bugs.ruby-lang.org/