optimize widenUnion

Author: noti0na1

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

@@ -295,16 +295,8 @@ class Definitions {
   @tu lazy val AnyRefAlias: TypeSymbol = enterAliasType(tpnme.AnyRef, ObjectType)
   def AnyRefType: TypeRef = AnyRefAlias.typeRef
 
-    @tu lazy val Object_eq: TermSymbol = {
-      // If explicit nulls is enabled, then we want to allow `(x: String).eq(null)`, so we need
-      // to adjust the signature of `eq` accordingly.
-      enterMethod(ObjectClass, nme.eq, methOfAnyRefOrNull(BooleanType), Final)
-    }
-    @tu lazy val Object_ne: TermSymbol = {
-      // If explicit nulls is enabled, then we want to allow `(x: String).ne(null)`, so we need
-      // to adjust the signature of `ne` accordingly.
-      enterMethod(ObjectClass, nme.ne, methOfAnyRefOrNull(BooleanType), Final)
-    }
+    @tu lazy val Object_eq: TermSymbol = enterMethod(ObjectClass, nme.eq, methOfAnyRef(BooleanType), Final)
+    @tu lazy val Object_ne: TermSymbol = enterMethod(ObjectClass, nme.ne, methOfAnyRef(BooleanType), Final)
     @tu lazy val Object_synchronized: TermSymbol = enterPolyMethod(ObjectClass, nme.synchronized_, 1,
         pt => MethodType(List(pt.paramRefs(0)), pt.paramRefs(0)), Final)
     @tu lazy val Object_clone: TermSymbol = enterMethod(ObjectClass, nme.clone_, MethodType(Nil, ObjectType), Protected)
@@ -839,7 +831,7 @@ class Definitions {
   // convenient one-parameter method types
   def methOfAny(tp: Type): MethodType = MethodType(List(AnyType), tp)
   def methOfAnyVal(tp: Type): MethodType = MethodType(List(AnyValType), tp)
-  def methOfAnyRefOrNull(tp: Type): MethodType = MethodType(List(ObjectType.maybeNullable), tp)
+  def methOfAnyRef(tp: Type): MethodType = MethodType(List(ObjectType), tp)
 
   // Derived types
 

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

@@ -1102,30 +1102,30 @@ 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.
      */
-    def widenUnion(implicit ctx: Context): Type = {
-      widen match {
-        case tp @ OrType(lhs, rhs) =>
-          tp match {
-            case OrNull(tp1) =>
-              // Don't widen `T|Null`, since otherwise we wouldn't be able to infer nullable unions.
-              val tp1Widen = tp1.widenUnion
-              if (tp1Widen.isRef(defn.AnyClass)) tp1Widen
-              else tp.derivedOrType(tp1Widen, defn.NullType)
-            case _ =>
-              ctx.typeComparer.lub(lhs.widenUnion, rhs.widenUnion, canConstrain = true) match {
-                case union: OrType => union.join
-                case res => res
-              }
-          }
-        case tp @ AndType(tp1, tp2) =>
-          tp derived_& (tp1.widenUnion, tp2.widenUnion)
-        case tp: RefinedType =>
-          tp.derivedRefinedType(tp.parent.widenUnion, tp.refinedName, tp.refinedInfo)
-        case tp: RecType =>
-          tp.rebind(tp.parent.widenUnion)
-        case tp =>
-          tp
-      }
+    def widenUnion(implicit ctx: Context): Type = widen match {
+      case tp @ OrNull(tp1): OrType =>
+        // Don't widen `T|Null`, since otherwise we wouldn't be able to infer nullable unions.
+        val tp1Widen = tp1.widenUnion
+        if (tp1Widen.isRef(defn.AnyClass)) tp1Widen
+        else tp.derivedOrType(tp1Widen, defn.NullType)
+      case tp =>
+        tp.widenUnionWithoutNull
+    }
+
+    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 res => res
+        }
+      case tp @ AndType(tp1, tp2) =>
+        tp derived_& (tp1.widenUnionWithoutNull, tp2.widenUnionWithoutNull)
+      case tp: RefinedType =>
+        tp.derivedRefinedType(tp.parent.widenUnion, tp.refinedName, tp.refinedInfo)
+      case tp: RecType =>
+        tp.rebind(tp.parent.widenUnion)
+      case tp =>
+        tp
     }
 
     /** Widen all top-level singletons reachable by dealiasing