Fix #3332: Disallow bound variables in pattern alternatives

[odersky]

Disallow bound variables where the binder appears as a pattern alternative.

Fixes #3332.

There's nothing we can do about the parsing. If we parsed

case x: A | B 

as

case x: (A | B)

then we would run into an error for

case _: A | _: B

But the latter is a common idiom.

[smarter]

There's nothing we can do about the parsing.

Maybe when we report this error we could add "did you mean case x : (A | B) ?" if A | B is a valid type

[smarter]

Or maybe we need more backtracking in the parser :)

[smarter]

we would run into an error for
case _: A | _: B
But the latter is a common idiom.

One compromise could be: do backtracking under Scala2 mode but warn people when we backtrack that they should write (_: A) | (_: B) (for Scala 2 compatiblity) or _: A | B (which is more natural but incompatible).

[odersky]

@smarter It's actually worse than that. Here's some code that is legal now, but would mean something different if we changed the parsing scheme:

case class A
class B

case _: B | A

[smarter]

Actually, case class A isn't valid, you have to write case object A instead, and in that case case _: (B | A) wouldn't compile, it would have to be case _: (B | A.type)

[odersky]

Here's a more complete transscript of what goes wrong:

scala> case class A()
defined class A

scala> class B
defined class B

scala> (A(): Any) match { case _: B | A => "ok" case _ => "no" }
res1: String = no

That's the current behavior. If we change the parsing, we'd get "ok" instead.

[allanrenucci]

It doesn't work in this case (_ seems to be treated as a variable):

class Test {
  case class A()
  def test(x: Any) = x match {
    case _: String | _ @ A() => 1
  }
}

15 |    case _: String | _ @ A() => 1
   |                         ^^^
   |                         Illegal variable in pattern alternative

[allanrenucci]

Why did you rename this value? I think the old name is more consistent with the other mode's name

[odersky]

It's because otherwise we'd risk that someone thinks it's Pattern | Type only. And PatternOrTypeorInPatternAlternative was too long.

[odersky]

@allanrenucci The failure should be fixed now.

[smarter]

scala> case class A()
defined class A
scala> class B
defined class B
scala> (A(): Any) match { case _: B | A => "ok" case _ => "no" }
res1: String = no

This is a bit off-topic at this point, but I would argue that we're not doing anyone any favour by accepting this without at least a warning: it's extremely rare to want to pattern match on the companion object of a case class and is most likely to happen when trying to pattern match on the case class itself. I would rewrite A as _: A.type to make the meaning obvious.