Merge pull request scala#6216 from retronym/ticket/sd455

Revert "Type Alternative patterns as the lub of their branches."

Author: SethTisue

spec/08-pattern-matching.md

@@ -280,15 +280,11 @@ shorthand for the constructor or extractor pattern $\mathit{op}(p, q_1
   Pattern   ::=  Pattern1 { ‘|’ Pattern1 }
 ```
 
-A _pattern alternative_ `$p_1$ | $\ldots$ | $p_n$` consists of a number of 
-_alternative patterns_ $p_i$. All alternative patterns are type checked with 
-the expected type of the pattern. The type of the pattern alternative is the 
-[weak least upper bound](03-types.html#weak-conformance) of the types of 
-$p_1 , \ldots , p_n$.
-
-Alternative patterns may not bind variables other than wildcards. 
-The alternative pattern matches a value $v$ if at least one its alternatives 
-matches $v$.
+A _pattern alternative_ `$p_1$ | $\ldots$ | $p_n$`
+consists of a number of alternative patterns $p_i$. All alternative
+patterns are type checked with the expected type of the pattern. They
+may not bind variables other than wildcards. The alternative pattern
+matches a value $v$ if at least one its alternatives matches $v$.
 
 ### XML Patterns
 

src/compiler/scala/tools/nsc/typechecker/Typers.scala

@@ -1185,15 +1185,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
       } else tree.tpe match {
         case atp @ AnnotatedType(_, _) if canAdaptAnnotations(tree, this, mode, pt) => // (-1)
           adaptAnnotations(tree, this, mode, pt)
-        case ct @ ConstantType(value) if mode.inNone(TYPEmode | FUNmode | PATTERNmode) && (ct <:< pt) && canAdaptConstantTypeToLiteral => // (0)
-          /* We don't adapt in PATTERNmode because patmat checks for duplicated
-           * alternatives later on in MatchOptimizations, so that this desugars
-           * to a single check. Moreover, as we don't adaptConstant now, we are
-           * able to issue a "duplicated alternative" warning at the same time;
-           * see scala/bug#7290 for context. Theoretically I could warn earlier
-           * in typedAlternative, but there are other checks done in patmat, so
-           * it's easier just to wait until then.
-           */
+        case ct @ ConstantType(value) if mode.inNone(TYPEmode | FUNmode) && (ct <:< pt) && canAdaptConstantTypeToLiteral => // (0)
           adaptConstant(value)
         case OverloadedType(pre, alts) if !mode.inFunMode => // (1)
           inferExprAlternative(tree, pt)
@@ -5262,11 +5254,9 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
       }
 
       def typedAlternative(alt: Alternative) = {
-        context withinPatAlternative {
-          val trees1 = alt.trees mapConserve (alt => typed(alt, mode, pt))
-          val tpe = if (settings.isScala213) weakLub(trees1 map (_.tpe)) else pt
-          treeCopy.Alternative(tree, trees1) setType tpe
-        }
+        context withinPatAlternative (
+          treeCopy.Alternative(tree, alt.trees mapConserve (alt => typed(alt, mode, pt))) setType pt
+        )
       }
       def typedStar(tree: Star) = {
         if (!context.starPatterns && !isPastTyper)

src/reflect/scala/reflect/internal/tpe/GlbLubs.scala

@@ -219,7 +219,7 @@ private[internal] trait GlbLubs {
   def sameWeakLubAsLub(tps: List[Type]) = tps match {
     case Nil       => true
     case tp :: Nil => !typeHasAnnotations(tp)
-    case tps       => !(tps exists typeHasAnnotations) && !shouldUseNumericLub(tps)
+    case tps       => !(tps exists typeHasAnnotations) && !(tps forall isNumericValueType)
   }
 
   /** If the arguments are all numeric value types, the numeric
@@ -231,17 +231,14 @@ private[internal] trait GlbLubs {
   def weakLub(tps: List[Type]): Type = (
     if (tps.isEmpty)
       NothingTpe
-    else if (shouldUseNumericLub(tps))
+    else if (tps forall isNumericValueType)
       numericLub(tps)
     else if (tps exists typeHasAnnotations)
       annotationsLub(lub(tps map (_.withoutAnnotations)), tps)
     else
       lub(tps)
   )
 
-  private def shouldUseNumericLub(tps: List[Type]) =
-    tps forall (tp => isNumericValueType(tp.widen))
-
   def numericLub(ts: List[Type]) =
     ts reduceLeft ((t1, t2) =>
       if (isNumericSubType(t1, t2)) t2

test/files/pos/alternative-lubs.flags

@@ -0,0 +1,3 @@
+true
+false
+default

test/files/pos/alternative-lubs.scala

@@ -0,0 +1,10 @@
+object Const { final val VAL = 1 ; final val VAR = 2 }
+import Const._
+object Test {
+  def test(i: Int) = i match { case v @ (VAR | VAL) => v == VAR case _ => "default" }
+  def main(args: Array[String]) {
+    println(test(VAR))
+    println(test(VAL))
+    println(test(-1))
+  }
+}