Type Alternative patterns as the lub of their branches.

This came up on gitter a few weeks back, and the spec is
rather ambiguous on whether this happens or not, tersely
claiming that "All alternative patterns are type checked
with the expected type of the pattern". As such, this is
a bit of a spaghetti PR (in the "throw it at the wall to
see if it sticks" sense) motivated by checking Dotty and
seeing that The Future Of Scala™ duly types alternatives
in this way.

This will live behind a version flag because the sharper
type could accidentally change a public API if there was
no type ascription provided.

Also here is a tweak to weakLub so that it also uses the
numeric lub for singleton types of numbers. Otherwise we
get strange things like

    scala> def ct(v: Any) = ConstantType(Constant(v))
    ct: (v: Any)$r.intp.global.UniqueConstantType

    scala> val (one, twoL) = (ct(1), ct(2L))
    one: $r.intp.global.UniqueConstantType = Int(1)
    twoL: $r.intp.global.UniqueConstantType = Long(2L)

    scala> weakLub(one :: twoL :: Nil)
    res0: $r.intp.global.Type = AnyVal

    scala> weakLub((one :: twoL :: Nil) map (_.widen))
    res1: $r.intp.global.Type = Long

which just cannot be right.

The spec is now updated accordingly.

Review by adriaanm, retronym

Author: hrhino

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

@@ -1174,7 +1174,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)
@@ -5224,9 +5232,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

@@ -218,7 +218,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
@@ -230,14 +230,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
+}