Add notNull member to Any

Add a method $nn to Any that has type

    def $nn: this.type & NotNull

The method is marked as stable & realizable, which means it can appear in paths.
Special handling is required in asSeenFrom, to reflect the fact that $nn are not
real selections, i.e. the selected item has the same owner as the one in the prefix.

N.B. I tried to make $nn a field instead, but this caused AbstractMethod errors
for reasons I cannot quite track down.

Author: odersky

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

@@ -254,7 +254,7 @@ class Definitions {
       List(AnyClass.typeRef, NotNullClass.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,6 +263,8 @@ 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
 
@@ -275,7 +277,9 @@ class Definitions {
           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_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
 
   @tu lazy val ObjectClass: ClassSymbol = {
     val cls = ctx.requiredClass("java.lang.Object")

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

@@ -262,6 +262,7 @@ object StdNames {
     val MIRROR_PREFIX: N            = "$m."
     val MIRROR_SHORT: N             = "$m"
     val MIRROR_UNTYPED: N           = "$m$untyped"
+    val NOT_NULL: N                 = "$nn"
     val REIFY_FREE_PREFIX: N        = "free$"
     val REIFY_FREE_THIS_SUFFIX: N   = "$this"
     val REIFY_FREE_VALUE_SUFFIX: N  = "$value"

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

@@ -197,6 +197,7 @@ 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))

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

@@ -81,7 +81,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
                   // called which we override to set the `approximated` flag.
                   range(defn.NothingType, pre)
               else pre
-            else if ((pre.termSymbol is Package) && !(thiscls is Package))
+            else if (pre.termSymbol.is(Package) && !thiscls.is(Package))
               toPrefix(pre.select(nme.PACKAGE), cls, thiscls)
             else
               toPrefix(pre.baseType(cls).normalizedPrefix, cls.owner, thiscls)

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -426,6 +426,8 @@ 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 = {

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

@@ -269,7 +269,7 @@ object Nullables with
    *  Therefore, variables with unreachable assignments can be assumed to be not-null
    *  only if their type asserts it.
    *
-   *  Note: we the local variables through their offset and not through their name
+   *  Note: we track the local variables through their offset and not through their name
    *  because of shadowing.
    */
   def assignmentSpans(given Context): Map[Int, List[Span]] =

compiler/src/dotty/tools/repl/ReplDriver.scala

@@ -272,7 +272,7 @@ class ReplDriver(settings: Array[String],
 
       val vals =
         info.fields
-          .filterNot(_.symbol.isOneOf(ParamAccessor | Private | Synthetic | Module))
+          .filterNot(_.symbol.isOneOf(ParamAccessor | Private | Synthetic | Artifact | Module))
           .filter(_.symbol.name.is(SimpleNameKind))
           .sortBy(_.name)
 

tests/pos/notNull.scala

@@ -18,4 +18,16 @@ object Test with
     val y = notNull(identity(x)); val yc: Int = y
     val z = notNull(x); val zc: Int = z
   }
+  locally {
+    val x: Int | Null = ???
+    val y = identity(x).$nn; val yc: Int = y
+    val z = x.$nn; val zc: Int = z
+  }
+  class C { type T }
+  locally {
+    val x: C { type T = Int } = new C { type T = Int }
+    val y: x.$nn.T = 33
+    val z = y; val zc: Int = z
+  }
+
 

tests/run-macros/i6518.check

@@ -2,6 +2,7 @@
 ##
 $asInstanceOf$
 $isInstanceOf$
+$nn
 ==
 andThen
 apply