Fix #3332: Disallow bound variable sin pattern alternatives

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

Author: odersky

compiler/src/dotty/tools/dotc/core/Mode.scala

@@ -8,7 +8,7 @@ case class Mode(val bits: Int) extends AnyVal {
   def &~ (that: Mode) = Mode(bits & ~that.bits)
   def is (that: Mode) = (bits & that.bits) == that.bits
 
-  def isExpr = (this & PatternOrType) == None
+  def isExpr = (this & PatternOrTypeBits) == None
 
   override def toString =
     (0 until 31).filter(i => (bits & (1 << i)) != 0).map(modeName).mkString("Mode(", ",", ")")
@@ -42,6 +42,9 @@ object Mode {
   /** We are looking at the arguments of a supercall */
   val InSuperCall = newMode(6, "InSuperCall")
 
+  /** We are in a pattern alternative */
+  val InPatternAlternative = newMode(7, "InPatternAlternative")
+
   /** Allow GADTFlexType labelled types to have their bounds adjusted */
   val GADTflexible = newMode(8, "GADTflexible")
 
@@ -87,7 +90,7 @@ object Mode {
   /** Don't suppress exceptions thrown during show */
   val PrintShowExceptions = newMode(18, "PrintShowExceptions")
 
-  val PatternOrType = Pattern | Type
+  val PatternOrTypeBits = Pattern | Type | InPatternAlternative
 
   /** We are elaborating the fully qualified name of a package clause.
    *  In this case, identifiers should never be imported.

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -936,10 +936,10 @@ class Namer { typer: Typer =>
   }
 
   def typedAheadType(tree: Tree, pt: Type = WildcardType)(implicit ctx: Context): tpd.Tree =
-    typedAheadImpl(tree, typer.typed(_, pt)(ctx retractMode Mode.PatternOrType addMode Mode.Type))
+    typedAheadImpl(tree, typer.typed(_, pt)(ctx retractMode Mode.PatternOrTypeBits addMode Mode.Type))
 
   def typedAheadExpr(tree: Tree, pt: Type = WildcardType)(implicit ctx: Context): tpd.Tree =
-    typedAheadImpl(tree, typer.typed(_, pt)(ctx retractMode Mode.PatternOrType))
+    typedAheadImpl(tree, typer.typed(_, pt)(ctx retractMode Mode.PatternOrTypeBits))
 
   def typedAheadAnnotation(tree: Tree)(implicit ctx: Context): Symbol = tree match {
     case Apply(fn, _) => typedAheadAnnotation(fn)

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1211,12 +1211,14 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
             typed(untpd.Bind(tree.name, untpd.TypedSplice(arg)).withPos(tree.pos), arg.tpe) :: Nil)
       case _ =>
         val sym = newPatternBoundSym(tree.name, body1.tpe, tree.pos)
+        if (ctx.mode.is(Mode.InPatternAlternative)) ctx.error("Illegal variable in pattern alternative", tree.pos)
         assignType(cpy.Bind(tree)(tree.name, body1), sym)
     }
   }
 
   def typedAlternative(tree: untpd.Alternative, pt: Type)(implicit ctx: Context): Alternative = track("typedAlternative") {
-    val trees1 = tree.trees mapconserve (typed(_, pt))
+    val nestedCtx = ctx.addMode(Mode.InPatternAlternative)
+    val trees1 = tree.trees.mapconserve(typed(_, pt)(nestedCtx))
     assignType(cpy.Alternative(tree)(trees1), trees1)
   }
 
@@ -1754,7 +1756,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         Inliner.removeInlineAccessors(mdef.symbol)
 
   def typedExpr(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree =
-    typed(tree, pt)(ctx retractMode Mode.PatternOrType)
+    typed(tree, pt)(ctx retractMode Mode.PatternOrTypeBits)
   def typedType(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree = // todo: retract mode between Type and Pattern?
     typed(tree, pt)(ctx addMode Mode.Type)
   def typedPattern(tree: untpd.Tree, selType: Type = WildcardType)(implicit ctx: Context): Tree =

tests/neg/i3332.scala

@@ -0,0 +1,9 @@
+object Main {
+  def main(args: Array[String]): Unit = {
+    (1: Any) match {
+      case x: String | Int => "OK"
+      case (_: String) | (_: Int) => "OK"
+      case (s: String) | _: Int => s   // error: Illegal variable in pattern alternative
+    }
+  }
+}