Simplify isUnsafelyConvertible

Author: noti0na1

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

@@ -58,8 +58,8 @@ object NullOpsDecorator {
       stripped ne self
     }
 
-    /** Can the type has null value after erasure?
-     */
+    /** Can the type has null value after erasure? */
+    // TODO
     def isNullableAfterErasure(using Context): Boolean =  self match {
       case tp: ClassInfo => tp.cls.isNullableClassAfterErasure
       case tp: TypeProxy => tp.underlying.isNullableAfterErasure
@@ -74,17 +74,9 @@ object NullOpsDecorator {
     def isUnsafelyNulltoAnyRef(pt: Type)(using Context): Boolean =
       self.isNullType && pt.isNullableAfterErasure
 
-    def isUnsafeSubtype(pt: Type, relaxedSubtype: Boolean = false)(using Context): Boolean =
-      val selfs = self.stripAllNulls
-      val pts = pt.stripAllNulls
-      if relaxedSubtype then
-        selfs relaxed_<:< pts
-      else
-        selfs <:< pts
-
-    /** Can we convert a tree with type `self` to type `pt` unsafely.
-     */
+    /** Can we convert a tree with type `self` to type `pt` unsafely. */
     def isUnsafelyConvertible(pt: Type, relaxedSubtype: Boolean = false)(using Context): Boolean =
-      self.isUnsafelyNulltoAnyRef(pt) || self.isUnsafeSubtype(pt, relaxedSubtype)
+      self.isUnsafelyNulltoAnyRef(pt)
+      || TypeComparer.topLevelSubTypeIgnoringNulls(self, pt)
   }
 }

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -135,7 +135,7 @@ object Implicits:
                   if (approx) formal = wildApprox(formal)
                   explore((argType relaxed_<:< formal.widenExpr) ||
                     Nullables.convertUnsafeNulls &&
-                      argType.isUnsafeSubtype(formal.widenExpr, true))
+                      argType.isUnsafelyConvertible(formal.widenExpr))
                 })
               Candidate.Conversion
             else