Change/drop not null

src/dotty/tools/dotc/TypeErasure.scala

@@ -253,7 +253,7 @@ class TypeErasure(isJava: Boolean, isSemi: Boolean, isConstructor: Boolean, wild
    *      - otherwise, if T is a type paramter coming from Java, []Object
    *      - otherwise, Object
    *   - For a term ref p.x, the type <noprefix> # x.
-   *   - For a typeref scala.Any, scala.AnyVal, scala.Singleon or scala.NotNull: |java.lang.Object|
+   *   - For a typeref scala.Any, scala.AnyVal or scala.Singleton: |java.lang.Object|
    *   - For a typeref scala.Unit, |scala.runtime.BoxedUnit|.
    *   - For a typeref P.C where C refers to a class, <noprefix> # C.
    *   - For a typeref P.C where C refers to an alias type, the erasure of C's alias.
@@ -374,7 +374,7 @@ class TypeErasure(isJava: Boolean, isSemi: Boolean, isConstructor: Boolean, wild
 
   private def normalizeClass(cls: ClassSymbol)(implicit ctx: Context): ClassSymbol = {
     if (cls.owner == defn.ScalaPackageClass) {
-      if (cls == defn.AnyClass || cls == defn.AnyValClass || cls == defn.SingletonClass || cls == defn.NotNullClass)
+      if (cls == defn.AnyClass || cls == defn.AnyValClass || cls == defn.SingletonClass)
         return defn.ObjectClass
       if (cls == defn.UnitClass)
         return defn.BoxedUnitClass

src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -140,7 +140,6 @@ class ScalaSettings extends Settings.SettingGroup {
   val Ybuilderdebug = ChoiceSetting("-Ybuilder-debug", "manager", "Compile using the specified build manager.", List("none", "refined", "simple"), "none")
   val Yreifycopypaste = BooleanSetting("-Yreify-copypaste", "Dump the reified trees in copypasteable representation.")
   val Yreplsync = BooleanSetting("-Yrepl-sync", "Do not use asynchronous code for repl startup")
-  val Ynotnull = BooleanSetting("-Ynotnull", "Enable (experimental and incomplete) scala.NotNull.")
   val YmethodInfer = BooleanSetting("-Yinfer-argument-types", "Infer types for arguments of overriden methods.")
   val etaExpandKeepsStar = BooleanSetting("-Yeta-expand-keeps-star", "Eta-expand varargs methods to T* rather than Seq[T].  This is a temporary option to ease transition.")
   val Yinvalidate = StringSetting("-Yinvalidate", "classpath-entry", "Invalidate classpath entry before run", "")

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

@@ -177,8 +177,6 @@ class Definitions {
       RootClass, nme.dummyApply, 1,
       pt => MethodType(List(FunctionType(Nil, PolyParam(pt, 0))), PolyParam(pt, 0)))
 
-  lazy val NotNullClass = ctx.requiredClass("scala.NotNull")
-
   lazy val NothingClass: ClassSymbol = newCompleteClassSymbol(
     ScalaPackageClass, tpnme.Nothing, AbstractFinal, List(AnyClass.typeRef))
   lazy val NullClass: ClassSymbol = newCompleteClassSymbol(
@@ -348,7 +346,6 @@ class Definitions {
   def AnyValType: Type = AnyValClass.typeRef
   def ObjectType: Type = ObjectClass.typeRef
   def AnyRefType: Type = AnyRefAlias.typeRef
-  def NotNullType: Type = NotNullClass.typeRef
   def NothingType: Type = NothingClass.typeRef
   def NullType: Type = NullClass.typeRef
   def SeqType: Type = SeqClass.typeRef

src/dotty/tools/dotc/core/SymDenotations.scala

@@ -466,7 +466,7 @@ object SymDenotations {
 
     /** Is this symbol a class references to which that are supertypes of null? */
     final def isNullableClass(implicit ctx: Context): Boolean =
-      isNonValueClass && !(this is ModuleClass) // todo: check that class does not derive from NotNull?
+      isNonValueClass && !(this is ModuleClass)
 
     /** Is this definition accessible as a member of tree with type `pre`?
      *  @param pre          The type of the tree from which the selection is made

src/dotty/tools/dotc/core/TypeComparer.scala

@@ -648,8 +648,7 @@ class TypeComparer(initctx: Context) extends DotClass {
           if (cls2.isClass) {
             val base = tp1.baseTypeRef(cls2)
             if (base.exists && (base ne tp1)) return isSubType(base, tp2)
-            if ( cls2 == defn.SingletonClass && tp1.isStable
-               || cls2 == defn.NotNullClass && tp1.isNotNull) return true
+            if (cls2 == defn.SingletonClass && tp1.isStable) return true
           }
           tryRebase3rd
       }
@@ -777,8 +776,13 @@ class TypeComparer(initctx: Context) extends DotClass {
         case TypeBounds(lo1, hi1) =>
           isSubType(hi1, tp2)
         case _ =>
+          def isNullable(tp: Type): Boolean = tp.dealias match {
+            case tp: TypeRef => tp.symbol.isNullableClass
+            case RefinedType(parent, _) => isNullable(parent)
+            case _ => false
+          }
           (tp1.symbol eq NothingClass) && tp2.isInstanceOf[ValueType] ||
-          (tp1.symbol eq NullClass) && tp2.dealias.typeSymbol.isNullableClass
+          (tp1.symbol eq NullClass) && isNullable(tp2)
       }
     case tp1: SingletonType =>
       isNewSubType(tp1.underlying.widenExpr, tp2) || {

tests/pos/i262-null-subtyping.scala

@@ -0,0 +1,19 @@
+object O {
+  // This compiles
+  val a: { type T } = null;
+  val b: Any { type T } = null;
+
+  // This doesn't:
+  // found   : Null
+  // required: AnyRef{T}
+  val c: AnyRef { type T } = null;
+
+  class A
+  class B
+
+  val d: A & B = null
+  val e: A | B = null
+
+  val f: (A & B) { def toString: String } = null
+  val g: (A | B) { def toString: String } = null
+}