[ruby-core:115668] [Ruby master Bug#19392] Endless method and parsing priorities

Issue #19392 has been updated by duerst (Martin D=FCrst).





> Because `a =3D b and c` is interpreted as `(a =3D b) and c`, it is natura=
l that `def a =3D b and c` is interpreted as `(def a =3D b) and c`



I agree with others that there's not much (if anything) natural about this.=
 In `def a =3D 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=3D` operator. This `de=
f=3D` operator has lower precedence than `and` or `if` or `unless`,... As a=
 result, `def a =3D b and c` is interpreted as `def a =3D (b and c)`, which=
 is easier to understand and more useful (because it is the more frequent u=
secase).



Parsing this so that `def=3D` 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 difficu=
lty'.[1] It would be weird if we gave up in this case because of 'parser di=
fficulty'. `def=3D` has the huge advantage that `def` is prefix, which is m=
uch easier to handle in parsers that an infix or postfix operator.



[1] The opposite of this is Pascal and other languages created by Niklaus W=
irth. Wirths main goal when designing a language was to make the compiler e=
asy 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) b=
y Lucian Ghinda:=20



```ruby

def test =3D 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 =3D puts("foo") and puts("bar")')

#  =3D>=20

# (SCOPE@1:0-1:38                                                        =20

#  tbl: []                                                               =20

#  args: nil                                                             =20

#  body:                                                                 =20

#    (AND@1:0-1:38                                                       =20

#       (DEFN@1:0-1:22                                                   =20

#        mid: :test                                                      =20

#        body:                                                           =20

#          (SCOPE@1:0-1:22                                               =20

#           tbl: []                                                      =20

#           args:                                                        =20

#             (ARGS@1:0-1:8 pre_num: 0 pre_init: nil opt: nil first_post: n=
il 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 "fo=
o") nil))))

#       (FCALL@1:27-1:38 :puts (LIST@1:32-1:37 (STR@1:32-1:37 "bar") nil)))=
)=20

```



E.g. it is parsed as=20

```ruby

(def test =3D puts("foo")) and (puts("bar"))

```

...which is hardly intentional or have any practical use. The rightly parse=
d code in this case _can_ have practical use, like

```ruby

def write(data) =3D File.write(@filename, data) =3D=3D data.size or raise "=
Something went wrong"

```



**Additional cases of what seems to be the same problem**



```ruby

def save =3D File.write(name, self.to_yaml) unless invalid?

# Parsed as:

(def save =3D 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) =3D @a, b =3D a, b

# syntax error, unexpected ',', expecting end-of-input (SyntaxError)       =
                                         =20

# def initialize(a, b) =3D @a, b =3D a, b                           =20

#                          ^        =20



# Again, parsed as

(def initialize(a, b) =3D @a), b =3D a, b

```

While this one is at least diagnosed early, in pathological cases, it might=
 lead to very subtle bugs:

```ruby

private def start =3D @operation, @conversion =3D :print, :to_s

```

This code doesn't throw a syntax error, but its effect is very far from exp=
ected. Again, it is parsed as

```ruby

private( (def start =3D @operation), @conversion =3D :print, :to_s )

```

...and ends up in:

* defining a private method `start`

* making private methods `:print` and `:to_s`









--=20

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-c=
ore.ml.ruby-lang.org/