Merge pull request scala#6025 from hrhino/feature/alternative-lubs

Type Alternative patterns as the lub of their branches.

Author: retronym

spec/08-pattern-matching.md

@@ -280,11 +280,15 @@ 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. They
-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. 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$.
 
 ### XML Patterns
 

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

@@ -1185,7 +1185,15 @@ 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) && (ct <:< pt) && canAdaptConstantTypeToLiteral => // (0)
+        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.
+           */
           adaptConstant(value)
         case OverloadedType(pre, alts) if !mode.inFunMode => // (1)
           inferExprAlternative(tree, pt)
@@ -5254,9 +5262,11 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
       }
 
       def typedAlternative(alt: Alternative) = {
-        context withinPatAlternative (
-          treeCopy.Alternative(tree, alt.trees mapConserve (alt => typed(alt, mode, pt))) setType pt
-        )
+        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
+        }
       }
       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) && !(tps forall isNumericValueType)
+    case tps       => !(tps exists typeHasAnnotations) && !shouldUseNumericLub(tps)
   }
 
   /** If the arguments are all numeric value types, the numeric
@@ -231,14 +231,17 @@ private[internal] trait GlbLubs {
   def weakLub(tps: List[Type]): Type = (
     if (tps.isEmpty)
       NothingTpe
-    else if (tps forall isNumericValueType)
+    else if (shouldUseNumericLub(tps))
       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 @@
+-Xsource:2.13

test/files/pos/alternative-lubs.scala

@@ -0,0 +1,27 @@
+sealed trait A
+sealed trait B extends A
+case class B1(i: Int) extends B
+case class B2(i: Int) extends B
+
+object Test {
+  val b1: B1 = B1(0)
+  val b2: B2 = B2(0)
+
+  def takesB(b: B): Int = 10
+  def takesB1(it: b1.type): Int = 11
+
+  def foo0(a: A) = a match {
+    case b @ (`b1` | `b2`) => takesB(b)
+    case b @ (_ : `b1`.type | _ : `b2`.type) => takesB(b)
+    case b @ (_ : `b1`.type | _ : `b1`.type) => takesB1(b)
+    case b @ (B1(_) | B2(_)) => takesB(b)
+    case _ => 20
+  }
+
+  // weak subtyping, fun...
+  def foo1(a: Option[Any]) = (a : @unchecked) match { case Some(x @ (1 | 1)) => x }
+  def foo2(a: Option[Any]) = (a : @unchecked) match { case Some(x @ (1 | 1L)) => x }
+
+  foo1(None) : Int
+  foo2(None) : Long
+}