fix return from orphan Proc in lambda

A "return" statement in a Proc in a lambda like:
  `lambda{ proc{ return }.call }`
should return outer lambda block. However, the inner Proc can become
orphan Proc from the lambda block. This "return" escape outer-scope
like method, but this behavior was decieded as a bug.
[Bug #17105]

This patch raises LocalJumpError by checking the proc is orphan or
not from lambda blocks before escaping by "return".

Most of tests are written by Jeremy Evans
https://github.com/ruby/ruby/pull/4223
This commit is contained in:
Koichi Sasada 2021-04-02 02:28:00 +09:00
parent c080bb2284
commit ecfa8dcdba
Notes: git 2021-04-02 09:25:55 +09:00
2 changed files with 134 additions and 7 deletions

View File

@ -74,6 +74,109 @@ class TestLambdaParameters < Test::Unit::TestCase
assert_raise(ArgumentError, bug9605) {proc(&plus).call [1,2]} assert_raise(ArgumentError, bug9605) {proc(&plus).call [1,2]}
end end
def test_proc_inside_lambda_inside_method_return_inside_lambda_inside_method
def self.a
r = -> do
p = Proc.new{return :a}
p.call
end.call
end
assert_equal(:a, a)
def self.b
r = lambda do
p = Proc.new{return :b}
p.call
end.call
end
assert_equal(:b, b)
end
def test_proc_inside_lambda_inside_method_return_inside_lambda_outside_method
def self.a
r = -> do
p = Proc.new{return :a}
p.call
end
end
assert_equal(:a, a.call)
def self.b
r = lambda do
p = Proc.new{return :b}
p.call
end
end
assert_equal(:b, b.call)
end
def test_proc_inside_lambda_inside_method_return_outside_lambda_inside_method
def self.a
r = -> do
Proc.new{return :a}
end.call.call
end
assert_raise(LocalJumpError) {a}
def self.b
r = lambda do
Proc.new{return :b}
end.call.call
end
assert_raise(LocalJumpError) {b}
end
def test_proc_inside_lambda_inside_method_return_outside_lambda_outside_method
def self.a
r = -> do
Proc.new{return :a}
end
end
assert_raise(LocalJumpError) {a.call.call}
def self.b
r = lambda do
Proc.new{return :b}
end
end
assert_raise(LocalJumpError) {b.call.call}
end
def test_proc_inside_lambda2_inside_method_return_outside_lambda1_inside_method
def self.a
r = -> do
-> do
Proc.new{return :a}
end.call.call
end.call
end
assert_raise(LocalJumpError) {a}
def self.b
r = lambda do
lambda do
Proc.new{return :a}
end.call.call
end.call
end
assert_raise(LocalJumpError) {b}
end
def test_proc_inside_lambda_toplevel
assert_separately [], <<~RUBY
lambda{
$g = proc{ return :pr }
}.call
begin
$g.call
rescue LocalJumpError
# OK!
else
raise
end
RUBY
end
def pass_along(&block) def pass_along(&block)
lambda(&block) lambda(&block)
end end

View File

@ -1390,13 +1390,22 @@ vm_throw_start(const rb_execution_context_t *ec, rb_control_frame_t *const reg_c
} }
else if (state == TAG_RETURN) { else if (state == TAG_RETURN) {
const VALUE *current_ep = GET_EP(); const VALUE *current_ep = GET_EP();
const VALUE *target_lep = VM_EP_LEP(current_ep); const VALUE *target_ep = NULL, *target_lep, *ep = current_ep;
int in_class_frame = 0; int in_class_frame = 0;
int toplevel = 1; int toplevel = 1;
escape_cfp = reg_cfp; escape_cfp = reg_cfp;
while (escape_cfp < eocfp) { // find target_lep, target_ep
const VALUE *lep = VM_CF_LEP(escape_cfp); while (!VM_ENV_LOCAL_P(ep)) {
if (VM_ENV_FLAGS(ep, VM_FRAME_FLAG_LAMBDA) && target_ep == NULL) {
target_ep = ep;
}
ep = VM_ENV_PREV_EP(ep);
}
target_lep = ep;
while (escape_cfp < eocfp) {
const VALUE *lep = VM_CF_LEP(escape_cfp);
if (!target_lep) { if (!target_lep) {
target_lep = lep; target_lep = lep;
@ -1414,7 +1423,7 @@ vm_throw_start(const rb_execution_context_t *ec, rb_control_frame_t *const reg_c
toplevel = 0; toplevel = 0;
if (in_class_frame) { if (in_class_frame) {
/* lambda {class A; ... return ...; end} */ /* lambda {class A; ... return ...; end} */
goto valid_return; goto valid_return;
} }
else { else {
const VALUE *tep = current_ep; const VALUE *tep = current_ep;
@ -1422,7 +1431,12 @@ vm_throw_start(const rb_execution_context_t *ec, rb_control_frame_t *const reg_c
while (target_lep != tep) { while (target_lep != tep) {
if (escape_cfp->ep == tep) { if (escape_cfp->ep == tep) {
/* in lambda */ /* in lambda */
goto valid_return; if (tep == target_ep) {
goto valid_return;
}
else {
goto unexpected_return;
}
} }
tep = VM_ENV_PREV_EP(tep); tep = VM_ENV_PREV_EP(tep);
} }
@ -1434,7 +1448,12 @@ vm_throw_start(const rb_execution_context_t *ec, rb_control_frame_t *const reg_c
case ISEQ_TYPE_MAIN: case ISEQ_TYPE_MAIN:
if (toplevel) { if (toplevel) {
if (in_class_frame) goto unexpected_return; if (in_class_frame) goto unexpected_return;
goto valid_return; if (target_ep == NULL) {
goto valid_return;
}
else {
goto unexpected_return;
}
} }
break; break;
case ISEQ_TYPE_EVAL: case ISEQ_TYPE_EVAL:
@ -1448,7 +1467,12 @@ vm_throw_start(const rb_execution_context_t *ec, rb_control_frame_t *const reg_c
} }
if (escape_cfp->ep == target_lep && escape_cfp->iseq->body->type == ISEQ_TYPE_METHOD) { if (escape_cfp->ep == target_lep && escape_cfp->iseq->body->type == ISEQ_TYPE_METHOD) {
goto valid_return; if (target_ep == NULL) {
goto valid_return;
}
else {
goto unexpected_return;
}
} }
escape_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(escape_cfp); escape_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(escape_cfp);