Fix-scala#4867 Keep Unions when explicit

Improves the inference of union types by preserving the
union when there is a type ascription with an union.

If the term has not been explicity ascribed with an union then
the existing semantics of joining the orType is maintained.

To determine whether an explicit union ascription exists, a lexical
check on the untyped tree is performed.

Author: landerlo

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

@@ -23,6 +23,7 @@ import util.SimpleIdentitySet
 import reporting.diagnostic.Message
 import ast.tpd._
 import ast.TreeTypeMap
+import ast.untpd
 import printing.Texts._
 import printing.Printer
 import Hashable._
@@ -38,6 +39,7 @@ import java.lang.ref.WeakReference
 
 import scala.annotation.internal.sharable
 import scala.annotation.threadUnsafe
+import dotty.tools.dotc.ast.Trees.Untyped
 
 import dotty.tools.dotc.transform.SymUtils._
 
@@ -1099,7 +1101,7 @@ object Types {
      *  re-lubbing it while allowing type parameters to be constrained further.
      *  Any remaining union types are replaced by their joins.
      *
-	   *  For instance, if `A` is an unconstrained type variable, then
+	 *  For instance, if `A` is an unconstrained type variable, then
   	 *
   	 * 	      ArrayBuffer[Int] | ArrayBuffer[A]
   	 *
@@ -1108,6 +1110,8 @@ object Types {
      *
      *  Exception (if `-YexplicitNulls` is set): if this type is a nullable union (i.e. of the form `T | Null`),
      *  then the top-level union isn't widened. This is needed so that type inference can infer nullable types.
+     *
+     *  Another exception is when there is an explicit type ascription, then the union isn't widened.
      */
     def widenUnion(implicit ctx: Context): Type = widen match {
       case tp @ OrNull(tp1): OrType =>
@@ -1122,7 +1126,14 @@ object Types {
     def widenUnionWithoutNull(implicit ctx: Context): Type = widen match {
       case tp @ OrType(lhs, rhs) =>
         ctx.typeComparer.lub(lhs.widenUnionWithoutNull, rhs.widenUnionWithoutNull, canConstrain = true) match {
-          case union: OrType => union.join
+          case union: OrType =>
+                val keepUnion = ctx.tree match {
+                  case DefDef(_, _, _, untpd.TypedSplice(_), _)   => true
+                  case ValDef(name, untpd.InfixOp(_, op, _), _)   => op.symbol == ctx.definitions.orType
+                  case _                                          => false
+                }
+                if (keepUnion) union else union.join
+
           case res => res
         }
       case tp @ AndType(tp1, tp2) =>