Do not widen nullable unions

We need to be able to infer nullable unions:

val s = someJavaMethod // need s: String|JavaNull inferred

Normally, unions are widened when inferred, so we need to special case
nullable unions.

Author: abeln

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

@@ -1179,12 +1179,21 @@ object Types {
   	 *
      *  is approximated by constraining `A` to be =:= to `Int` and returning `ArrayBuffer[Int]`
      *  instead of `ArrayBuffer[_ >: Int | A <: Int & A]`
+     *
+     *  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.
      */
     def widenUnion(implicit ctx: Context): Type = this match {
       case OrType(tp1, tp2) =>
-        ctx.typeComparer.lub(tp1.widenUnion, tp2.widenUnion, canConstrain = true) match {
-          case union: OrType => union.join
-          case res => res
+        if (ctx.settings.YexplicitNulls.value && isNullableUnion) {
+          // Don't widen `T|Null`, since otherwise we wouldn't be able to infer nullable unions.
+          val OrType(leftTpe, nullTpe) = normNullableUnion
+          OrType(leftTpe.widenUnion, nullTpe)
+        } else {
+          ctx.typeComparer.lub(tp1.widenUnion, tp2.widenUnion, canConstrain = true) match {
+            case union: OrType => union.join
+            case res => res
+          }
         }
       case tp @ AndType(tp1, tp2) =>
         tp derived_& (tp1.widenUnion, tp2.widenUnion)

tests/explicit-nulls/pos/dont-widen-src/J.java

@@ -0,0 +1,3 @@
+class J {
+	String foo() { return "hello"; }
+}

tests/explicit-nulls/pos/dont-widen-src/S.scala

@@ -0,0 +1,7 @@
+class S {
+  val j = new J()
+  val x = j.foo()
+  // Check that the type of `x` is inferred to be `String|Null`.
+  // i.e. the union isn't collapsed.
+  val y: String|Null = x
+}

tests/explicit-nulls/pos/dont-widen.scala

@@ -0,0 +1,8 @@
+
+class S {
+  def foo[T](x: T): T = x
+  // Check that the type argument to `foo` is inferred to be
+  // `String|Null`: i.e. it isn't collapsed.
+  val x = foo(if (1 == 2) "hello" else null)
+  val y: String|Null = x
+}