From: "mame (Yusuke Endoh) via ruby-core" <ruby-core@...>
Date: 2025-12-05T13:13:49+00:00
Subject: [ruby-core:124037] [Ruby Bug#21669] Thoroughly implement void value expression check

Issue #21669 has been updated by mame (Yusuke Endoh).


Earlopain (Earlopain _) wrote in #note-6:
> I have an implementation in [https://github.com/ruby/prism/pull/3728](https://github.com/ruby/prism/pull/3728) (maybe needs more tests)

Great, thanks!

> How about waiting on Ruby 4.1 for this?

Agreed. I think the evaluation window is too short to introduce this now, and considering the concern raised by nobu, we may need to make some adjustments.

nobu (Nobuyoshi Nakada) wrote in #note-7:
> Sorry, I've missed this issue.

Don't be sorry, thank you!

> But 2 is intentionally passed, IIRC, and bootraptest has such code.

I don't think `bootstraptest` necessarily reflects real-world use cases, but I think users might write code that returns in the middle of a `begin` block, such as during debugging. This disturbs such code.

@matz What do you think?

----------------------------------------
Bug #21669: Thoroughly implement void value expression check
https://bugs.ruby-lang.org/issues/21669#change-115468

* Author: mame (Yusuke Endoh)
* Status: Open
* Assignee: prism
* Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN
----------------------------------------
A void-value-expression check is a syntax check that raises a `SyntaxError` if an expression that cannot grammatically return a value (a "void value expression," such as a `return` expression) appears in a context where a value is expected (e.g., the right-hand side of an assignment, the argument of a method call, etc.). A typical example rejected by this check is `x = return`.

However, it has become clear that this check is incomplete. This ticket summarizes the results of a discussion with @matz at the hackathon before RubyWorld Conference today.

## 1\. Expressions containing branches

@matz said that an expression containing branches should be considered a void value expression only if it can be grammatically determined that all possible branches do not return a value.

Based on this, both parse.y and prism currently reject the following code with a "void value expression" `SyntaxError`, but it should be accepted:

```ruby
x = begin
  raise
  return
rescue
  "OK"
else
  return
end
# Expected: Code parses and executes successfully.
# Actual: Rejected with "unexpected void value expression" SyntaxError.
```

Reason: The `rescue` clause can return a value ("OK"), so the entire `begin` expression is not void.

Conversely, the following code is currently accepted by both parse.y and prism, but it should be rejected:

```ruby
x = begin
  foo
rescue
  return
else
  return
end
# Expected: Rejected with SyntaxError.
# Actual: Code parses and executes.
```

Reason: This expression always does `return`, so it is void whether `foo` raises an exception or not.

Furthermore, `case` expressions must also be rejected similarly when all branches are void:

```ruby
x =
  case
  when 1; return
  when 2; return
  else return
  end
# Expected: Rejected with SyntaxError.
# Actual: Code parses and executes.
```

Note that `if` expressions appear to be implemented correctly as intended:

```ruby
x = if rand < 0.5
  return
else
  return
end
# Expected: Rejected with SyntaxError.
# Actual: Rejected. (OK!)
```

## 2\. Statement lists containing a void value expression

@matz also said that if a statements node contains a void value expression, the entire statement list should be treated as a void value expression, even if the void expression is not the last one.

Therefore, the following code is currently accepted but should be rejected:

```ruby
x = begin
  return
  "NG"
end
# Expected: Rejected with SyntaxError.
# Actual: Code parses and executes.
```

The same applies to branches within other expressions:

```ruby
x = if rand < 0.5
  return
  "NG"
else
  return
end
# Expected: Rejected with SyntaxError.
# Actual: Code parses and executes.
```

Note that if a return statement is inside a branch, that statement cannot be considered a void value expression, so the entire expression also cannot be a void value expression.

```ruby
x = begin
  return if true
  "NG"
end
# Expected: Code parses and executes.
# Actual: Code parses and executes as expected. (OK!)
```

---

This is considered a bug, but if it causes practical compatibility issues, it may be necessary to plan a migration path or revisit the specifications.

(Both prism and parse.y need to be fixed, but I'll assign it to the prism team for now.)



-- 
https://bugs.ruby-lang.org/
______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/