From: eregontp@...
Date: 2020-08-06T11:00:33+00:00
Subject: [ruby-core:99500] [Ruby master Bug#17105] A single `return` can return to two different places in a proc inside a lambda inside a method

Issue #17105 has been updated by Eregon (Benoit Daloze).


I should also note some of these semantics might significantly harm the performance of Ruby.
CRuby seems to walk the stack on every `return`.
On others VMs there need to be some extra logic to find if the frame to return to is still on the stack.
It's already quite complicated but then if `return` can go to two places, it becomes a huge mess.

----------------------------------------
Bug #17105: A single `return` can return to two different places in a proc inside a lambda inside a method
https://bugs.ruby-lang.org/issues/17105#change-86957

* Author: Eregon (Benoit Daloze)
* Status: Open
* Priority: Normal
* Backport: 2.5: UNKNOWN, 2.6: UNKNOWN, 2.7: UNKNOWN
----------------------------------------
A single `return` in the source code might return to 2 different lexical places.
That seems wrong to me, as AFAIK all other control flow language constructs always jump to a single place.

```ruby
def m(call_proc)
  r = -> {
    # This single return in the source might exit the lambda or the method!
    proc = Proc.new { return :return }

    if call_proc
      proc.call
      :after_in_lambda
    else
      proc
    end
  }.call # returns here if call_proc

  if call_proc
    [:after_in_method, r]
  else
    r.call
    :never_reached
  end
end


p m(true)  # => [:after_in_method, :return]
p m(false) # :return
```

We're trying to figure out the semantics of `return` inside a proc in
https://github.com/oracle/truffleruby/issues/1488#issuecomment-669185675
and this behavior doesn't seem to make much sense.

@headius also seems to agree:
> I would consider that behavior to be incorrect; once the proc has escaped from the lambda, its return target is no longer valid. It should not return to a different place.
> https://github.com/jruby/jruby/issues/6350#issuecomment-669603740

So:
* is this behavior intentional? or is it a bug?
* what are actually the semantics of `return` inside a proc?

The semantics seem incredibly complicated to a point developers have no idea where `return` actually goes.
Also it must get even more complicated if one defines a `lambda` method as the block in `lambda { return }` is then non-deterministically a proc or lambda.



-- 
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>