Pattern `given` on the LHS of a `val` definition should enter corresponding scope

Compiler version

3.0.0-RC1

Minimized code

scala> given Int = 0
lazy val given_Int: Int

scala> def test = {
     |   val (x, given Int) = (1, 1)
     |   summon[Int]
     | }
def test: Int

scala> test                                                                                                             
val res0: Int = 0

Expectation

This is quite surprising/unexpected.

I would expect it to work in the same way as the following:

scala> def test = {
     |   given Int = 1
     |   summon[Int]
     | }
def test: Int

scala> test
val res1: Int = 1

[LPTK]

Yes, but that’s totally unexpected from a user point of view.

I always thought the desugaring of local val bindings with patterns was unnecessarily convoluted and allocation-heavy.

The correct approach would be to desugar them as:

def test = {
  (1, 1) match
  case (x, given Int) =>
    summon[Int]
    ... // rest of the block
}

Though this does not really generalize to member vals, which I am not convinced should be allowed to bind patterns anyway.

[odersky]

Though this does not really generalize to member vals, which I am not convinced should be allowed to bind patterns anyway.

Note: this would also mean that toplevel vals and object vals cannot be allowed to bind patterns. So a rather drastic change.