Always widen or-types when inferring types

The idea is that or-types should never be inferred, so
we widen them

 - when instantiating type variables
 - when computing the type of valdef or defdefs from the rhs.

This is already done in harmonizeUnion. However, harmonizeUnion
had the restrictions that it joined or-types only in Scala2 mode.
This restriction is now dropped.

Author: odersky

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

@@ -271,7 +271,7 @@ trait ConstraintHandling {
     // 2. If instance is from below and is a fully-defined union type, yet upper bound
     // is not a union type, approximate the union type from above by an intersection
     // of all common base types.
-    if (fromBelow && isOrType(inst) && isFullyDefined(inst) && !isOrType(upperBound))
+    if (fromBelow && isOrType(inst) && /*isFullyDefined(inst) &&*/ !isOrType(upperBound))
       inst = ctx.harmonizeUnion(inst)
 
     inst

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

@@ -300,7 +300,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
 
   /** Under -language:Scala2: Replace or-types with their joins */
   private def joinIfScala2(tp: Type) = tp match {
-    case tp: OrType if scala2Mode => tp.join
+    case tp: OrType => tp.join
     case _ => tp
   }
 

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

@@ -830,23 +830,23 @@ object Types {
      *  def o: Outer
      *  <o.x.type>.widen = o.C
      */
-    @tailrec final def widen(implicit ctx: Context): Type = widenSingleton match {
+    final def widen(implicit ctx: Context): Type = widenSingleton match {
       case tp: ExprType => tp.resultType.widen
       case tp => tp
     }
 
     /** Widen from singleton type to its underlying non-singleton
      *  base type by applying one or more `underlying` dereferences.
      */
-    @tailrec final def widenSingleton(implicit ctx: Context): Type = stripTypeVar match {
+    final def widenSingleton(implicit ctx: Context): Type = stripTypeVar match {
       case tp: SingletonType if !tp.isOverloaded => tp.underlying.widenSingleton
       case _ => this
     }
 
     /** Widen from TermRef to its underlying non-termref
      *  base type, while also skipping Expr types.
      */
-    @tailrec final def widenTermRefExpr(implicit ctx: Context): Type = stripTypeVar match {
+    final def widenTermRefExpr(implicit ctx: Context): Type = stripTypeVar match {
       case tp: TermRef if !tp.isOverloaded => tp.underlying.widenExpr.widenTermRefExpr
       case _ => this
     }
@@ -860,7 +860,7 @@ object Types {
     }
 
     /** Widen type if it is unstable (i.e. an ExprType, or TermRef to unstable symbol */
-    @tailrec final def widenIfUnstable(implicit ctx: Context): Type = stripTypeVar match {
+    final def widenIfUnstable(implicit ctx: Context): Type = stripTypeVar match {
       case tp: ExprType => tp.resultType.widenIfUnstable
       case tp: TermRef if !tp.symbol.isStable => tp.underlying.widenIfUnstable
       case _ => this

compiler/test/dotc/tests.scala

@@ -167,6 +167,7 @@ class tests extends CompilerTest {
   @Test def rewrites = compileFile(posScala2Dir, "rewrites", "-rewrite" :: scala2mode)
 
   @Test def pos_t8146a = compileFile(posSpecialDir, "t8146a")(allowDeepSubtypes)
+  @Test def pos_jon = compileFile(posSpecialDir, "jon")(allowDeepSubtypes)
 
   @Test def pos_t5545 = {
     // compile by hand in two batches, since junit lacks the infrastructure to

tests/neg/union.scala

@@ -0,0 +1,28 @@
+object Test {
+
+  class A
+  class B extends A
+  class C extends A
+  class D extends A
+
+  val b = true
+  val x = if (b) new B else new C
+  val y: B | C = x  // error
+}
+
+object O {
+  class A
+  class B
+  def f[T](x: T, y: T): T = x
+
+  val x: A = f(new A { }, new A)
+
+  val y1: A | B = f(new A { }, new B) // error
+  val y2: A | B = f[A | B](new A { }, new B) // ok
+
+  val z = if (???) new A{} else new B
+
+  val z1: A | B = z // error
+
+  val z2: A | B = if (???) new A else new B // ok
+}

tests/pos/jon.scala renamed to tests/pos-special/jon.scala

@@ -5,5 +5,5 @@ object O {
 
   val x: A = f(new A { }, new A)
 
-  val y: A | B = f(new A { }, new B)
+  val z: A | B = if (???) new A{} else new A
 }

tests/pos/anonClassSubtyping.scala

@@ -17,7 +17,7 @@ object Test {
 
   val x: Inv[Int] = inv(true)
 
-  def inv2(cond: Boolean) =
+  def inv2(cond: Boolean): Inv[Int] | Inv2[Int] =
     if (cond) {
       if (cond)
         new Inv(1)

tests/pos/constraining-lub.scala

@@ -9,7 +9,9 @@ object intersection {
   val z = if (???) x else y
 
   val a: A & B => Unit = z
-  val b: (A => Unit) | (B => Unit) = z
+  //val b: (A => Unit) | (B => Unit) = z // error under new or-type rules
+
+  val c: (A => Unit) | (B => Unit) = if (???) x else y // ok
 
   type needsA = A => Nothing
   type needsB = B => Nothing