From: nobu@...
Date: 2021-02-11T01:02:56+00:00
Subject: [ruby-core:102451] [Ruby master Bug#17621] Ripper can call on_parse_error multiple times for syntax error. Is this correct?

Issue #17621 has been updated by nobu (Nobuyoshi Nakada).


mauro_oto (Mauro Otonelli) wrote:
> The source it's parsing has a syntax error, so I would only expect one parse error. However, when you execute this code, you see two:
> 
> ``` ruby
> MyRipperSubclass.new(source).parse
> # => {:count=>1, :msg=>"syntax error, unexpected `end', expecting ']'"}
> # => {:count=>2, :msg=>"syntax error, unexpected end-of-input, expecting `end'"}
> ```

As you can see with `ruby -c`, it is an expected behavior.

```
$ ruby -c
  module Hey
    class Foo
      def initialize
        [1,2,3
      end
      def call
      end
    end
  end
-:5: syntax error, unexpected `end', expecting ']'
      end
-:9: syntax error, unexpected end-of-input, expecting `end'
```

It is very usual that one error causes many succeeding errors, not only in Ruby.

> If this is expected, can you give me more context?

What do you mean by "more context"?

> Is there an upper bound to the number of parse errors a document can generate?

No upper bound currently.

> Is the order guaranteed?

The order is the errors are generated.
But it may not be same as the source code.


----------------------------------------
Bug #17621: Ripper can call on_parse_error multiple times for syntax error. Is this correct?
https://bugs.ruby-lang.org/issues/17621#change-90337

* Author: mauro_oto (Mauro Otonelli)
* Status: Open
* Priority: Normal
* ruby -v: 2.7.2
* Backport: 2.5: UNKNOWN, 2.6: UNKNOWN, 2.7: UNKNOWN, 3.0: UNKNOWN
----------------------------------------
Here's an example subclass of Ripper:

``` ruby
class MyRipperSubclass < Ripper
  def on_parse_error(msg)
    @count ||= 0
    @count += 1
    puts [count: @count, msg: msg]
  end
end
source = <<~EOM
  module Hey
    class Foo
      def initialize
        [1,2,3
      end
      def call
      end
    end
  end
EOM
MyRipperSubclass.new(source).parse
```

The source it's parsing has a syntax error, so I would only expect one parse error. However, when you execute this code, you see two:

``` ruby
MyRipperSubclass.new(source).parse
# => {:count=>1, :msg=>"syntax error, unexpected `end', expecting ']'"}
# => {:count=>2, :msg=>"syntax error, unexpected end-of-input, expecting `end'"}
```

Is this a bug, or is this expected? If this is expected, can you give me more context? Is there an upper bound to the number of parse errors a document can generate? Is the order guaranteed? 



-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>