Feature #14463: Allow comments to precede dots in member expressions

• Status: Open
• Assignee: -
• Target version: -

[isiahmeadows (Isiah Meadows)]

I, coming from other languages, find it extremely odd that the first three are considered valid, but the fourth is a syntax error (tested in Ruby 2.3.4 + 2.5.0, Rubocop's parser for 2.3):

# 1
foo = -> {}
foo.
  call

# 2
foo = -> {}
foo.
  # comment
  call

# 3
foo = -> {}
foo
  .call

# 4
foo = -> {}
foo
  # comment
  .call

Any chance 4 could be fixed? (It looks more like a parser/spec bug than anything.)

[duerst (Martin Dürst)]

• Related to Feature #7639: More freedom for location of comments added

[duerst (Martin Dürst)]

There is extensive discussion on this at #7636. Please check.

[isiahmeadows (Isiah Meadows)]

duerst (Martin Dürst) wrote:

There is extensive discussion on this at #7636. Please check.

I presume you meant #7639...

I never found that due to probably its age and the fact it was in the other project.

I still find it very odd that it's inconsistent. The alternative to my proposal would be to make the third also error (as I presume it did previously), so it'll remain consistent across both. (Ruby isn't my primary language, so I'm still getting used to the language-level preference for dot-last.)

[duerst (Martin Dürst)]

isiahmeadows (Isiah Meadows) wrote:

duerst (Martin Dürst) wrote:

There is extensive discussion on this at #7636. Please check.

I presume you meant #7639...

Sorry.

I still find it very odd that it's inconsistent. The alternative to my proposal would be to make the third also error (as I presume it did previously), so it'll remain consistent across both. (Ruby isn't my primary language, so I'm still getting used to the language-level preference for dot-last.)

[The following is just a summary of the overall thinking, as I said details can be found at #7639.]

The way things work in Ruby in general is that the operator (and . is also an operator) has to come at the end of the line so that Ruby understands that the expression isn't finished at the end of the line.

An exception was made for . because it turned out that it was very useful in method chains to write the dot at the start of the line. However, that exception didn't go as far as to allow comments between the lines. The reason for this is that it may be difficult to parse both for humans (there could be a leading . after a 100 lines of comments, which would suddenly totally change the meaning of the line above the comment) as well as for the actual parser (the Ruby parser is already quite complicated anyway).

[shevegen (Robert A. Heiler)]

I still find it very odd that it's inconsistent.

Tsuyoshi Sawada pointed out something similar in the issue that
was referred to 5 years ago and I also agree with it.

I know little to nothing how ruby works internally but I would
have assumed that comments are completely ignored. Like "hello
ruby parser, ignore everything that comes on the line after a
'#' token". I should, however had, also say that I do not think
that I was ever affected by it; I don't think I wrote a .foo
method call on the next line, ever, in all my years of ruby. :)

The only excessive method chaining I sometimes do, but also quite
rarely, is something like this (semi-contrived):

object.sub(//,'').sub(//,'').sub(//,'').sub(//,'').
       sub(//,'').sub(//,'').sub(//,'').sub(//,'')

And I already considered that pretty strange to do, but I do that
very rarely ... though never with the '.' dot on a newline.

[isiahmeadows (Isiah Meadows)]

shevegen (Robert A. Heiler) wrote:

I still find it very odd that it's inconsistent.

Tsuyoshi Sawada pointed out something similar in the issue that
was referred to 5 years ago and I also agree with it.

I know little to nothing how ruby works internally but I would
have assumed that comments are completely ignored. Like "hello
ruby parser, ignore everything that comes on the line after a
'#' token". I should, however had, also say that I do not think
that I was ever affected by it; I don't think I wrote a .foo
method call on the next line, ever, in all my years of ruby. :)

It wasn't more than a month in that I first got bit. Like I said earlier, Ruby isn't my primary language (I started with Java, and JavaScript is my primary), so writing method calls on new lines is practically muscle memory at this point. Most other languages idiomatically prefer this, including those two languages, Python, Lua, and others.

The only excessive method chaining I sometimes do, but also quite
rarely, is something like this (semi-contrived):

object.sub(//,'').sub(//,'').sub(//,'').sub(//,'').
       sub(//,'').sub(//,'').sub(//,'').sub(//,'')

And I already considered that pretty strange to do, but I do that
very rarely ... though never with the '.' dot on a newline.

I've had method chains longer than that come up frequently, as:

1. I have a bit of a functional background and find myself using array methods quite a bit. Those can result in non-trivial method chains on occasion.
2. My company's main app is a pretty large, CRUD-ish app, so we do a lot of ActiveRecord queries (in a few files, there's several query chains that long).

[hsbt (Hiroshi SHIBATA)]

• Project changed from 14 to Ruby master