Rewrite isNullableType

noti0na1 · noti0na1 · commit ad580cec0bc4 · 2020-12-08T15:20:23.000-05:00
diff --git a/compiler/src/dotty/tools/dotc/core/NullOpsDecorator.scala b/compiler/src/dotty/tools/dotc/core/NullOpsDecorator.scala
@@ -61,15 +61,19 @@ object NullOpsDecorator {
     /** 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
-      case OrType(lhs, rhs) =>
-        lhs.isNullableAfterErasure || rhs.isNullableAfterErasure
-      case AndType(lhs, rhs) =>
-        lhs.isNullableAfterErasure && rhs.isNullableAfterErasure
-      case _ =>
-        self.isNullType || self <:< defn.ObjectType
-    }
+    // def isNullableAfterErasure(using Context): Boolean =  self match {
+    //   case tp: ClassInfo => tp.cls.isNullableClassAfterErasure
+    //   case tp: TypeProxy => tp.underlying.isNullableAfterErasure
+    //   case OrType(lhs, rhs) =>
+    //     lhs.isNullableAfterErasure || rhs.isNullableAfterErasure
+    //   case AndType(lhs, rhs) =>
+    //     lhs.isNullableAfterErasure && rhs.isNullableAfterErasure
+    //   case _ =>
+    //     self.isNullType || self <:< defn.ObjectType
+    // }
+    def isNullableAfterErasure(using Context): Boolean =
+      self.isNullType
+      || !self.isNothingType
+        && self.derivesFrom(defn.ObjectClass, afterErasure = true)
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -1790,7 +1790,9 @@ object SymDenotations {
       derivesFrom(base) ||
         base.isClass && (
           (symbol eq defn.NothingClass) ||
-            (symbol eq defn.NullClass) && (base ne defn.NothingClass))
+            (!ctx.explicitNulls || ctx.phase.erasedTypes)
+            && (symbol eq defn.NullClass)
+            && (base ne defn.NothingClass))
 
     /** Is it possible that a class inherits both `this` and `that`?
      *
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -1573,6 +1573,9 @@ object Types {
     /** Is this (an alias of) the `scala.Null` type? */
     final def isNullType(using Context) = isRef(defn.NullClass)
 
+    /** Is this (an alias of) the `scala.Nothing` type? */
+    final def isNothingType(using Context) = isRef(defn.NothingClass)
+
     /** The resultType of a LambdaType, or ExprType, the type itself for others */
     def resultType(using Context): Type = this
 
diff --git a/compiler/src/dotty/tools/dotc/interactive/Completion.scala b/compiler/src/dotty/tools/dotc/interactive/Completion.scala
@@ -10,6 +10,7 @@ import dotty.tools.dotc.core.CheckRealizable
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Denotations.SingleDenotation
 import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.{Mode => CMode}
 import dotty.tools.dotc.core.Names.{Name, TermName}
 import dotty.tools.dotc.core.NameKinds.SimpleNameKind
 import dotty.tools.dotc.core.NameOps._
@@ -252,7 +253,7 @@ object Completion {
         }
 
       // 2. The extension method is a member of some given instance that is visible at the point of the reference.
-      val givensInScope = ctx.implicits.eligible(defn.AnyType).map(_.implicitRef.underlyingRef)
+      val givensInScope = ctx.implicits.eligible(defn.AnyType, ctx.mode.is(CMode.UnsafeNullConversion)).map(_.implicitRef.underlyingRef)
       val extMethodsFromGivensInScope = extractDefinedExtensionMethods(givensInScope)
 
       // 3. The reference is of the form r.m and the extension method is defined in the implicit scope of the type of r.
