Revert all the changes that added NonNull.

sjrd · sjrd · commit b35fa495ca7a · 2019-11-14T17:29:14.000+01:00
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -249,12 +249,10 @@ class Definitions {
    */
   @tu lazy val AnyClass: ClassSymbol = completeClass(enterCompleteClassSymbol(ScalaPackageClass, tpnme.Any, Abstract, Nil), ensureCtor = false)
   def AnyType: TypeRef = AnyClass.typeRef
-  @tu lazy val AnyValClass: ClassSymbol = completeClass(
-    enterCompleteClassSymbol(ScalaPackageClass, tpnme.AnyVal, Abstract,
-      List(AnyClass.typeRef, NotNullClass.typeRef)))
+  @tu lazy val AnyValClass: ClassSymbol = completeClass(enterCompleteClassSymbol(ScalaPackageClass, tpnme.AnyVal, Abstract, List(AnyClass.typeRef)))
   def AnyValType: TypeRef = AnyValClass.typeRef
 
-    @tu lazy val Any_== : TermSymbol          = enterMethod(AnyClass, nme.EQ, methOfAny(BooleanType), Final)
+    @tu lazy val Any_== : TermSymbol           = enterMethod(AnyClass, nme.EQ, methOfAny(BooleanType), Final)
     @tu lazy val Any_!= : TermSymbol          = enterMethod(AnyClass, nme.NE, methOfAny(BooleanType), Final)
     @tu lazy val Any_equals: TermSymbol       = enterMethod(AnyClass, nme.equals_, methOfAny(BooleanType))
     @tu lazy val Any_hashCode: TermSymbol     = enterMethod(AnyClass, nme.hashCode_, MethodType(Nil, IntType))
@@ -263,8 +261,6 @@ class Definitions {
     @tu lazy val Any_isInstanceOf: TermSymbol = enterT1ParameterlessMethod(AnyClass, nme.isInstanceOf_, _ => BooleanType, Final)
     @tu lazy val Any_asInstanceOf: TermSymbol = enterT1ParameterlessMethod(AnyClass, nme.asInstanceOf_, _.paramRefs(0), Final)
     @tu lazy val Any_typeTest: TermSymbol     = enterT1ParameterlessMethod(AnyClass, nme.isInstanceOfPM, _ => BooleanType, Final | Synthetic | Artifact)
-    @tu lazy val Any_notNull: TermSymbol      = newSymbol(AnyClass, nme.NOT_NULL, Method | Final | Erased | Artifact| StableRealizable,
-                                                          AndType(AnyClass.thisType, NotNullClass.typeRef)).entered
     @tu lazy val Any_typeCast: TermSymbol     = enterT1ParameterlessMethod(AnyClass, nme.asInstanceOfPM, _.paramRefs(0), Final | Synthetic | Artifact | StableRealizable)
       // generated by pattern matcher, eliminated by erasure
 
@@ -276,16 +272,13 @@ class Definitions {
           Final,
           bounds = TypeBounds.lower(AnyClass.thisType))
 
-    private def AnyMethods: List[TermSymbol] = List(Any_==, Any_!=, Any_equals, Any_hashCode,
-      Any_toString, Any_##, Any_getClass, Any_isInstanceOf, Any_asInstanceOf, Any_typeTest, Any_typeCast, Any_notNull)
-
-    def isAny_notNull(sym: Symbol)(given Context) = sym.name == nme.NOT_NULL && sym == Any_notNull
+    def AnyMethods: List[TermSymbol] = List(Any_==, Any_!=, Any_equals, Any_hashCode,
+      Any_toString, Any_##, Any_getClass, Any_isInstanceOf, Any_asInstanceOf, Any_typeTest, Any_typeCast)
 
   @tu lazy val ObjectClass: ClassSymbol = {
     val cls = ctx.requiredClass("java.lang.Object")
     assert(!cls.isCompleted, "race for completing java.lang.Object")
-    cls.info = ClassInfo(cls.owner.thisType, cls,
-      List(AnyClass.typeRef, NotNullClass.typeRef), newScope)
+    cls.info = ClassInfo(cls.owner.thisType, cls, AnyClass.typeRef :: Nil, newScope)
     cls.setFlag(NoInits | JavaDefined)
 
     // The companion object doesn't really exist, so it needs to be marked as
@@ -410,11 +403,6 @@ class Definitions {
       List(AnyClass.typeRef), EmptyScope)
   @tu lazy val SingletonType: TypeRef = SingletonClass.typeRef
 
-  @tu lazy val NotNullClass: ClassSymbol =
-    enterCompleteClassSymbol(
-      ScalaPackageClass, tpnme.NotNull, PureInterfaceCreationFlags,
-      List(AnyClass.typeRef), EmptyScope)
-
   @tu lazy val CollectionSeqType: TypeRef = ctx.requiredClassRef("scala.collection.Seq")
   @tu lazy val SeqType: TypeRef = ctx.requiredClassRef("scala.collection.immutable.Seq")
   def SeqClass(given Context): ClassSymbol = SeqType.symbol.asClass
@@ -1302,7 +1290,6 @@ class Definitions {
       .updated(AnyClass, ObjectClass)
       .updated(AnyValClass, ObjectClass)
       .updated(SingletonClass, ObjectClass)
-      .updated(NotNullClass, ObjectClass)
       .updated(TupleClass, ObjectClass)
       .updated(NonEmptyTupleClass, ProductClass)
 
@@ -1319,7 +1306,6 @@ class Definitions {
     ByNameParamClass2x,
     AnyValClass,
     NullClass,
-    NotNullClass,
     NothingClass,
     SingletonClass)
 
diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -62,7 +62,6 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
   private var myAnyKindClass: ClassSymbol = null
   private var myNothingClass: ClassSymbol = null
   private var myNullClass: ClassSymbol = null
-  private var myNotNullClass: ClassSymbol = null
   private var myObjectClass: ClassSymbol = null
   private var myAnyType: TypeRef = null
   private var myAnyKindType: TypeRef = null
@@ -84,10 +83,6 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
     if (myNullClass == null) myNullClass = defn.NullClass
     myNullClass
   }
-  def NotNullClass: ClassSymbol =
-    if myNotNullClass == null then myNotNullClass = defn.NotNullClass
-    myNotNullClass
-
   def ObjectClass: ClassSymbol = {
     if (myObjectClass == null) myObjectClass = defn.ObjectClass
     myObjectClass
@@ -775,15 +770,6 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
         if (tp2a ne tp2) // Follow the alias; this might avoid truncating the search space in the either below
           return recur(tp1, tp2a)
 
-        if tp11.isRef(NotNullClass)
-          tp12.widen match
-            case OrNull(tp12a) if recur(tp12a, tp2) => return true
-            case _ =>
-        if tp12.isRef(NotNullClass)
-          tp11.widen match
-            case OrNull(tp11a) if recur(tp11a, tp2) => return true
-            case _ =>
-
         // Rewrite (T111 | T112) & T12 <: T2 to (T111 & T12) <: T2 and (T112 | T12) <: T2
         // and analogously for T11 & (T121 | T122) & T12 <: T2
         // `&' types to the left of <: are problematic, because
@@ -1056,7 +1042,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
      */
     def isNewSubType(tp1: Type): Boolean =
       if (isCovered(tp1) && isCovered(tp2))
-        //println(i"useless subtype: $tp1 <:< $tp2")
+        //println(s"useless subtype: $tp1 <:< $tp2")
         false
       else isSubType(tp1, tp2, approx.addLow)
 
@@ -1547,11 +1533,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
    *  combiners are AppliedTypes, RefinedTypes, RecTypes, And/Or-Types or AnnotatedTypes.
    */
   private def isCovered(tp: Type): Boolean = tp.dealiasKeepRefiningAnnots.stripTypeVar match {
-    case tp: TypeRef =>
-      tp.symbol.isClass
-      && tp.symbol != NothingClass
-      && tp.symbol != NullClass
-      && tp.symbol != NotNullClass
+    case tp: TypeRef => tp.symbol.isClass && tp.symbol != NothingClass && tp.symbol != NullClass
     case tp: AppliedType => isCovered(tp.tycon)
     case tp: RefinedOrRecType => isCovered(tp.parent)
     case tp: AndType => isCovered(tp.tp1) && isCovered(tp.tp2)
@@ -1719,27 +1701,28 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
             tp11 & tp2 | tp12 & tp2
           case _ =>
             val tp1a = dropIfSuper(tp1, tp2)
-            if (tp1a ne tp1) return glb(tp1a, tp2)
-            val tp2a = dropIfSuper(tp2, tp1)
-            if (tp2a ne tp2) return glb(tp1, tp2a)
-            tp1 match
-              case tp1: ConstantType =>
-                tp2 match
-                  case tp2: ConstantType =>
-                    // Make use of the fact that the intersection of two constant types
-                    // types which are not subtypes of each other is known to be empty.
-                    // Note: The same does not apply to singleton types in general.
-                    // E.g. we could have a pattern match against `x.type & y.type`
-                    // which might succeed if `x` and `y` happen to be the same ref
-                    // at run time. It would not work to replace that with `Nothing`.
-                    // However, maybe we can still apply the replacement to
-                    // types which are not explicitly written.
-                    return NothingType
-                  case _ =>
-              case _ =>
-            if tp1.isRef(NotNullClass) && tp2.isNull then return NothingType
-            if tp2.isRef(NotNullClass) && tp1.isNull then return NothingType
-            andType(tp1, tp2)
+            if (tp1a ne tp1) glb(tp1a, tp2)
+            else {
+              val tp2a = dropIfSuper(tp2, tp1)
+              if (tp2a ne tp2) glb(tp1, tp2a)
+              else tp1 match {
+                case tp1: ConstantType =>
+                  tp2 match {
+                    case tp2: ConstantType =>
+                      // Make use of the fact that the intersection of two constant types
+                      // types which are not subtypes of each other is known to be empty.
+                      // Note: The same does not apply to singleton types in general.
+                      // E.g. we could have a pattern match against `x.type & y.type`
+                      // which might succeed if `x` and `y` happen to be the same ref
+                      // at run time. It would not work to replace that with `Nothing`.
+                      // However, maybe we can still apply the replacement to
+                      // types which are not explicitly written.
+                      NothingType
+                    case _ => andType(tp1, tp2)
+                  }
+                case _ => andType(tp1, tp2)
+              }
+            }
         }
     }
   }
@@ -1855,7 +1838,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
     else if (!tp2.exists) tp1
     else tp.derivedAndType(tp1, tp2)
 
-  /** If some (&-operand of) `tp` is a supertype of `sub` replace it with `NoType`.
+  /** If some (&-operand of) this type is a supertype of `sub` replace it with `NoType`.
    */
   private def dropIfSuper(tp: Type, sub: Type): Type =
     if (isSubTypeWhenFrozen(sub, tp)) NoType
diff --git a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
@@ -197,7 +197,6 @@ object TypeErasure {
     else if (sym.isAbstractType) TypeAlias(WildcardType)
     else if (sym.isConstructor) outer.addParam(sym.owner.asClass, erase(tp)(erasureCtx))
     else if (sym.is(Label)) erase.eraseResult(sym.info)(erasureCtx)
-    else if sym.is(Erased) && defn.isAny_notNull(sym) then NoType // Q: Should we delete all erased symbols that way?
     else erase.eraseInfo(tp, sym)(erasureCtx) match {
       case einfo: MethodType =>
         if (sym.isGetter && einfo.resultType.isRef(defn.UnitClass))
diff --git a/compiler/src/dotty/tools/dotc/transform/Erasure.scala b/compiler/src/dotty/tools/dotc/transform/Erasure.scala
@@ -426,8 +426,6 @@ object Erasure {
      *      e.m -> e.[]m                if `m` is an array operation other than `clone`.
      */
     override def typedSelect(tree: untpd.Select, pt: Type)(implicit ctx: Context): Tree = {
-      if defn.isAny_notNull(tree.symbol) then return typed(tree.qualifier, pt)
-
       val qual1 = typed(tree.qualifier, AnySelectionProto)
 
       def mapOwner(sym: Symbol): Symbol = {
