[WIP] Scala with Explicit Nulls

compiler/src/dotty/tools/backend/jvm/scalaPrimitives.scala

@@ -155,11 +155,17 @@ class DottyPrimitives(ctx: Context) {
     addPrimitive(defn.Any_asInstanceOf, AS)
     addPrimitive(defn.Any_##, HASH)
 
+    // scala.Reference
+    addPrimitive(defn.RefEq_eq, ID)
+    addPrimitive(defn.RefEq_ne, NI)
+
     // java.lang.Object
+    /*
     addPrimitive(defn.Object_eq, ID)
     addPrimitive(defn.Object_ne, NI)
- /*   addPrimitive(defn.Any_==, EQ)
-    addPrimitive(defn.Any_!=, NE)*/
+    addPrimitive(defn.Any_==, EQ)
+    addPrimitive(defn.Any_!=, NE)
+    */
     addPrimitive(defn.Object_synchronized, SYNCHRONIZED)
     /*addPrimitive(defn.Any_isInstanceOf, IS)
     addPrimitive(defn.Any_asInstanceOf, AS)*/

compiler/src/dotty/tools/dotc/config/JavaPlatform.scala

@@ -43,7 +43,8 @@ class JavaPlatform extends Platform {
     cls.superClass == defn.ObjectClass &&
     cls.directlyInheritedTraits.forall(_.is(NoInits)) &&
     !ExplicitOuter.needsOuterIfReferenced(cls) &&
-    cls.typeRef.fields.isEmpty // Superaccessors already show up as abstract methods here, so no test necessary
+    cls.typeRef.fields.isEmpty &&
+    !cls.typeRef.abstractTermMembers.exists(_.symbol.isSuperAccessor)
 
   /** We could get away with excluding BoxedBooleanClass for the
    *  purpose of equality testing since it need not compare equal

compiler/src/dotty/tools/dotc/config/Printers.scala

@@ -39,4 +39,5 @@ object Printers {
   val typr: Printer = noPrinter
   val unapp: Printer = noPrinter
   val variances: Printer = noPrinter
+  val nullability: Printer = noPrinter
 }

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

@@ -27,8 +27,8 @@ import printing._
 import config.{JavaPlatform, SJSPlatform, Platform, ScalaSettings}
 
 import scala.annotation.internal.sharable
-
 import DenotTransformers.DenotTransformer
+import dotty.tools.dotc.core.FlowFacts.NonNullSet
 import dotty.tools.dotc.profile.Profiler
 import util.Property.Key
 import util.Store
@@ -142,6 +142,11 @@ object Contexts {
     protected def gadt_=(gadt: GADTMap): Unit = _gadt = gadt
     def gadt: GADTMap = _gadt
 
+    /** The terms currently known to be non-null (in spite of their declared type) */
+    private[this] var _nonNullFacts: NonNullSet = _
+    protected def nonNullFacts_=(nnSet: NonNullSet): Unit = _nonNullFacts = nnSet
+    def nonNullFacts: NonNullSet = _nonNullFacts
+
     /** The history of implicit searches that are currently active */
     private[this] var _searchHistory: SearchHistory = null
     protected def searchHistory_= (searchHistory: SearchHistory): Unit = _searchHistory = searchHistory
@@ -487,6 +492,8 @@ object Contexts {
     def setImportInfo(importInfo: ImportInfo): this.type = { this.importInfo = importInfo; this }
     def setGadt(gadt: GADTMap): this.type = { this.gadt = gadt; this }
     def setFreshGADTBounds: this.type = setGadt(gadt.fresh)
+    def setNonNullFacts(facts: NonNullSet): this.type = { this.nonNullFacts = facts; this }
+    def addNonNullFacts(facts: NonNullSet): this.type = { setNonNullFacts(this.nonNullFacts ++ facts); this }
     def setSearchHistory(searchHistory: SearchHistory): this.type = { this.searchHistory = searchHistory; this }
     def setTypeComparerFn(tcfn: Context => TypeComparer): this.type = { this.typeComparer = tcfn(this); this }
     private def setMoreProperties(moreProperties: Map[Key[Any], Any]): this.type = { this.moreProperties = moreProperties; this }
@@ -563,6 +570,7 @@ object Contexts {
     typeComparer = new TypeComparer(this)
     searchHistory = new SearchRoot
     gadt = EmptyGADTMap
+    nonNullFacts = FlowFacts.emptyNonNullSet
   }
 
   @sharable object NoContext extends Context {

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

@@ -3,7 +3,7 @@ package dotc
 package core
 
 import Types._, Contexts._, Symbols._, SymDenotations._, StdNames._, Names._
-import Flags._, Scopes._, Decorators._, NameOps._, Periods._
+import Flags._, Scopes._, Decorators._, NameOps._, Periods._, Annotations.Annotation
 import unpickleScala2.Scala2Unpickler.ensureConstructor
 import scala.collection.mutable
 import collection.mutable
@@ -278,7 +278,7 @@ class Definitions {
   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, AnyClass.typeRef :: Nil, newScope)
+    cls.info = ClassInfo(cls.owner.thisType, cls, AnyClass.typeRef :: RefEqClass.typeRef :: Nil, newScope)
     cls.setFlag(NoInits)
 
     // The companion object doesn't really exist, `NoType` is the general
@@ -295,8 +295,9 @@ class Definitions {
   lazy val AnyRefAlias: TypeSymbol = enterAliasType(tpnme.AnyRef, ObjectType)
   def AnyRefType: TypeRef = AnyRefAlias.typeRef
 
-    lazy val Object_eq: TermSymbol = enterMethod(ObjectClass, nme.eq, methOfAnyRef(BooleanType), Final)
-    lazy val Object_ne: TermSymbol = enterMethod(ObjectClass, nme.ne, methOfAnyRef(BooleanType), Final)
+    // TODO(abeln): modify usage sites to use `RefEq_eq/ne`?
+    lazy val Object_eq: TermSymbol = RefEq_eq
+    lazy val Object_ne: TermSymbol = RefEq_ne
     lazy val Object_synchronized: TermSymbol = enterPolyMethod(ObjectClass, nme.synchronized_, 1,
         pt => MethodType(List(pt.paramRefs(0)), pt.paramRefs(0)), Final)
     lazy val Object_clone: TermSymbol = enterMethod(ObjectClass, nme.clone_, MethodType(Nil, ObjectType), Protected)
@@ -327,23 +328,48 @@ class Definitions {
       pt => MethodType(List(FunctionOf(Nil, pt.paramRefs(0))), pt.paramRefs(0)))
 
   /** Method representing a throw */
-  lazy val throwMethod: TermSymbol = enterMethod(OpsPackageClass, nme.THROWkw,
-      MethodType(List(ThrowableType), NothingType))
+  lazy val throwMethod = enterMethod(OpsPackageClass, nme.THROWkw,
+      MethodType(List(OrType(ThrowableType, NullType)), NothingType))
 
   lazy val NothingClass: ClassSymbol = enterCompleteClassSymbol(
     ScalaPackageClass, tpnme.Nothing, AbstractFinal, List(AnyClass.typeRef))
   def NothingType: TypeRef = NothingClass.typeRef
   lazy val RuntimeNothingModuleRef: TermRef = ctx.requiredModuleRef("scala.runtime.Nothing")
+
+  /** `RefEq` is the trait defining the reference equality operators.
+   *  It's just a marker trait and there's no corresponding class file, since it gets erased to `Object`.
+   */
+  lazy val RefEqClass: ClassSymbol = enterCompleteClassSymbol(
+    ScalaPackageClass, tpnme.RefEq, Trait, AnyClass.typeRef :: Nil)
+  def RefEqType: TypeRef = RefEqClass.typeRef
+
+    lazy val RefEq_eq: TermSymbol = enterMethod(RefEqClass, nme.eq, MethodType(List(RefEqType), BooleanType), Final)
+    lazy val RefEq_ne: TermSymbol = enterMethod(RefEqClass, nme.ne, MethodType(List(RefEqType), BooleanType), Final)
+
+    def RefEqMethods: List[TermSymbol] = List(RefEq_eq, RefEq_ne)
+
   lazy val NullClass: ClassSymbol = enterCompleteClassSymbol(
-    ScalaPackageClass, tpnme.Null, AbstractFinal, List(ObjectClass.typeRef))
+    ScalaPackageClass, tpnme.Null, AbstractFinal, AnyClass.typeRef :: RefEqClass.typeRef :: Nil)
   def NullType: TypeRef = NullClass.typeRef
   lazy val RuntimeNullModuleRef: TermRef = ctx.requiredModuleRef("scala.runtime.Null")
 
+  /** An alias for null values that originate in Java code.
+   *  This type gets special treatment in the Typer. Specifically, `JavaNull` can be selected through:
+   *  e.g.
+   *  ```
+   *  // x: String|Null
+   *  x.length // error: `Null` has no `length` field
+   *  // x2: String|JavaNull
+   *  x2.length // allowed by the Typer, but unsound (might throw NPE)
+   *  ```
+   */
+  lazy val JavaNull = enterAliasType(tpnme.JavaNull, NullType)
+  def JavaNullType = JavaNull.typeRef
+
   lazy val ImplicitScrutineeTypeSym =
     newSymbol(ScalaPackageClass, tpnme.IMPLICITkw, EmptyFlags, TypeBounds.empty).entered
   def ImplicitScrutineeTypeRef: TypeRef = ImplicitScrutineeTypeSym.typeRef
 
-
   lazy val ScalaPredefModuleRef: TermRef = ctx.requiredModuleRef("scala.Predef")
   def ScalaPredefModule(implicit ctx: Context): Symbol = ScalaPredefModuleRef.symbol
 
@@ -962,10 +988,16 @@ class Definitions {
       name.length > prefix.length &&
       name.drop(prefix.length).forall(_.isDigit))
 
-  def isBottomClass(cls: Symbol): Boolean =
-    cls == NothingClass || cls == NullClass
-  def isBottomType(tp: Type): Boolean =
-    tp.derivesFrom(NothingClass) || tp.derivesFrom(NullClass)
+  def isBottomClass(cls: Symbol) = {
+    // After erasure, reference types become nullable again.
+    if (!ctx.phase.erasedTypes) cls == NothingClass
+    else cls == NothingClass || cls == NullClass
+  }
+  def isBottomType(tp: Type) = {
+    // After erasure, reference types become nullable again.
+    if (!ctx.phase.erasedTypes) tp.derivesFrom(NothingClass)
+    else tp.derivesFrom(NothingClass) || tp.derivesFrom(NullClass)
+  }
 
   /** Is a function class.
    *   - FunctionN for N >= 0
@@ -1054,7 +1086,8 @@ class Definitions {
 
   val PredefImportFns: List[() => TermRef] = List[() => TermRef](
     () => ScalaPredefModuleRef,
-    () => DottyPredefModuleRef
+    () => DottyPredefModuleRef,
+    () => ctx.requiredModuleRef("scala.NonNull") // TODO(abeln): move to right place
   )
 
   lazy val RootImportFns: List[() => TermRef] =
@@ -1069,7 +1102,7 @@ class Definitions {
   lazy val UnqualifiedOwnerTypes: Set[NamedType] =
     RootImportTypes.toSet[NamedType] ++ RootImportTypes.map(_.symbol.moduleClass.typeRef)
 
-  lazy val NotRuntimeClasses: Set[Symbol] = Set(AnyClass, AnyValClass, NullClass, NothingClass)
+  lazy val NotRuntimeClasses: Set[Symbol] = Set(AnyClass, AnyValClass, RefEqClass, NullClass, NothingClass)
 
   /** Classes that are known not to have an initializer irrespective of
    *  whether NoInits is set. Note: FunctionXXLClass is in this set
@@ -1257,13 +1290,14 @@ class Definitions {
   def isValueSubClass(sym1: Symbol, sym2: Symbol): Boolean =
     valueTypeEnc(sym2.asClass.name) % valueTypeEnc(sym1.asClass.name) == 0
 
-  lazy val erasedToObject: Set[Symbol] = Set(AnyClass, AnyValClass, TupleClass, NonEmptyTupleClass, SingletonClass)
+  lazy val erasedToObject: Set[Symbol] = Set(AnyClass, AnyValClass, RefEqClass, TupleClass, NonEmptyTupleClass, SingletonClass)
 
   // ----- Initialization ---------------------------------------------------
 
   /** Lists core classes that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */
   lazy val syntheticScalaClasses: List[TypeSymbol] = List(
     AnyClass,
+    RefEqClass,
     AnyRefAlias,
     AnyKindClass,
     RepeatedParamClass,
@@ -1280,7 +1314,7 @@ class Definitions {
 
   /** Lists core methods that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */
   lazy val syntheticCoreMethods: List[TermSymbol] =
-    AnyMethods ++ ObjectMethods ++ List(String_+, throwMethod)
+    AnyMethods ++ ObjectMethods ++ RefEqMethods ++ List(String_+, throwMethod)
 
   lazy val reservedScalaClassNames: Set[Name] = syntheticScalaClasses.map(_.name).toSet
 

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

@@ -478,7 +478,7 @@ object Flags {
   final val FromStartFlags: FlagSet =
     Module | Package | Deferred | Method.toCommonFlags |
     HigherKinded.toCommonFlags | Param | ParamAccessor.toCommonFlags |
-    Scala2ExistentialCommon | MutableOrOpaque | Touched | JavaStatic |
+    Scala2ExistentialCommon | MutableOrOpaque | Touched | JavaStatic | JavaDefined |
     CovariantOrOuter | ContravariantOrLabel | CaseAccessor.toCommonFlags |
     Extension.toCommonFlags | NonMember | ImplicitCommon | Permanent | Synthetic |
     SuperAccessorOrScala2x | Inline

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

@@ -0,0 +1,166 @@
+package dotty.tools.dotc.core
+
+import dotty.tools.dotc.ast.tpd._
+import StdNames.nme
+import dotty.tools.dotc.ast.Trees.{Tree => _, _}
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Constants.Constant
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Names.Name
+import dotty.tools.dotc.core.Types.{NonNullTermRef, TermRef, Type}
+
+import scala.annotation.internal.sharable
+
+/** Operations on flow-sensitive type information */
+object FlowFacts {
+
+  /** A set of `TermRef`s known to be non-null at the current program point */
+  type NonNullSet = Set[TermRef]
+
+  /** The initial state where no `TermRef`s are known to be non-null */
+  @sharable val emptyNonNullSet = Set.empty[TermRef]
+
+  /** Is `tref` non-null (even if its info says it isn't)? */
+  def isNonNull(nnSet: NonNullSet, tref: TermRef): Boolean = {
+    nnSet.contains(tref)
+  }
+
+  /** Try to improve the precision of `tpe` using flow-sensitive type information. */
+  def refineType(tpe: Type)(implicit ctx: Context): Type = tpe match {
+    case tref: TermRef if isNonNull(ctx.nonNullFacts, tref) =>
+      NonNullTermRef.fromTermRef(tref)
+    case _ => tpe
+  }
+
+  /** Nullability facts inferred from a condition.
+   *  @param ifTrue are the terms known to be non-null if the condition is true.
+   *  @param ifFalse are the terms known to be non-null if the condition is false.
+   */
+  case class Inferred(ifTrue: NonNullSet, ifFalse: NonNullSet) {
+    // Let `NN(e, true/false)` be the set of terms that are non-null if `e` evaluates to `true/false`.
+    // We can use De Morgan's laws to underapproximate `NN` via `Inferred`.
+    // e.g. say `e = e1 && e2`. Then if `e` is `false`, we know that either `!e1` or `!e2`.
+    // Let `t` be a term that is in both `NN(e1, false)` and `NN(e2, false)`.
+    // Then it follows that `t` must be in `NN(e, false)`. This means that if we set
+    // `Inferred(e1 && e2, false) = Inferred(e1, false) ∩ Inferred(e2, false)`, we'll have
+    // `Inferred(e1 && e2, false) ⊂ NN(e1 && e2, false)` (formally, we'd do a structural induction on `e`).
+    // This means that when we infer something we do so soundly. The methods below use this approach.
+
+    /** If `this` corresponds to a condition `e1` and `other` to `e2`, calculate the inferred facts for `e1 && e2`. */
+    def combineAnd(other: Inferred): Inferred = Inferred(ifTrue.union(other.ifTrue), ifFalse.intersect(other.ifFalse))
+
+    /** If `this` corresponds to a condition `e1` and `other` to `e2`, calculate the inferred facts for `e1 || e2`. */
+    def combineOr(other: Inferred): Inferred = Inferred(ifTrue.intersect(other.ifTrue), ifFalse.union(other.ifFalse))
+
+    /** The inferred facts for the negation of this condition. */
+    def negate: Inferred = Inferred(ifFalse, ifTrue)
+  }
+
+  object Inferred {
+    /** Create a singleton inferred fact containing `tref`. */
+    def apply(tref: TermRef, ifTrue: Boolean): Inferred = {
+      if (ifTrue) Inferred(Set(tref), emptyNonNullSet)
+      else Inferred(emptyNonNullSet, Set(tref))
+    }
+  }
+
+  /** Analyze the tree for a condition `cond` to learn new facts about non-nullability.
+   *  Supports ands, ors, and unary negation.
+   *
+   *  Example:
+   *  (1)
+   *  ```
+   *  val x: String|Null = "foo"
+   *  if (x != null) {
+   *    // x: String in the "then" branch
+   *  }
+   *  ```
+   * Notice that `x` must be stable for the above to work.
+   *
+   * TODO(abeln): add longer description of the algorithm
+   */
+  def inferNonNull(cond: Tree)(implicit ctx: Context): Inferred = {
+    /** Combine two sets of facts according to `op`. */
+    def combine(lhs: Inferred, op: Name, rhs: Inferred): Inferred = {
+      op match {
+        case _ if op == nme.ZAND => lhs.combineAnd(rhs)
+        case _ if op == nme.ZOR => lhs.combineOr(rhs)
+      }
+    }
+
+    val emptyFacts = Inferred(emptyNonNullSet, emptyNonNullSet)
+    val nullLit = tpd.Literal(Constant(null))
+
+    /** Recurse over a conditional to extract flow facts. */
+    def recur(tree: Tree): Inferred = {
+      tree match {
+        case Apply(Select(lhs, op), List(rhs)) =>
+          if (op == nme.ZAND || op == nme.ZOR) combine(recur(lhs), op, recur(rhs))
+          else if (op == nme.EQ || op == nme.NE || op == nme.eq || op == nme.ne) newFact(lhs, isEq = (op == nme.EQ || op == nme.eq), rhs)
+          else emptyFacts
+        case TypeApply(Select(lhs, op), List(targ)) if op == nme.isInstanceOf_ && targ.tpe.isRefToNull =>
+          // TODO(abeln): handle type test with argument that's not a subtype of `Null`.
+          // We could infer "non-null" in that case: e.g. `if (x.isInstanceOf[String]) { // x can't be null }`
+          newFact(lhs, isEq = true, nullLit)
+        case Select(lhs, neg) if neg == nme.UNARY_! => recur(lhs).negate
+        case Block(_, expr) => recur(expr)
+        case Inlined(_, _, expansion) => recur(expansion)
+        case Typed(expr, _) => recur(expr) // TODO(abeln): check that the type is `Boolean`?
+        case _ => emptyFacts
+      }
+    }
+
+    /** Extract new facts from an expression `lhs = rhs` or `lhs != rhs`
+     *  if either the lhs or rhs is the `null` literal.
+     */
+    def newFact(lhs: Tree, isEq: Boolean, rhs: Tree): Inferred = {
+      def isNullLit(tree: Tree): Boolean = tree match {
+        case Literal(const) if const.tag == Constants.NullTag => true
+        case _ => false
+      }
+
+      def isStableTermRef(tree: Tree): Boolean = asStableTermRef(tree).isDefined
+
+      def asStableTermRef(tree: Tree): Option[TermRef] = tree.tpe match {
+        case tref: TermRef if tref.isStable => Some(tref)
+        case _ => None
+      }
+
+      val trefOpt =
+        if (isNullLit(lhs) && isStableTermRef(rhs)) asStableTermRef(rhs)
+        else if (isStableTermRef(lhs) && isNullLit(rhs)) asStableTermRef(lhs)
+        else None
+
+      trefOpt match {
+        case Some(tref) =>
+          // If `isEq`, then the condition is of the form `lhs == null`,
+          // in which case we know `lhs` is non-null if the condition is false.
+          Inferred(tref, ifTrue = !isEq)
+        case _ => emptyFacts
+      }
+    }
+
+    recur(cond)
+  }
+
+  /** Propagate flow-sensitive type information inside a condition.
+   *  Specifically, if `cond` is of the form `lhs &&` or `lhs ||`, where the lhs has already been typed
+   *  (and the rhs hasn't been typed yet), compute the non-nullability info we get from lhs and
+   *  return a new context with it. The new context can then be used to type the rhs.
+   *
+   *  This is useful in e.g.
+   *  ```
+   *  val x: String|Null = ???
+   *  if (x != null && x.length > 0) ...
+   *  ```
+   */
+  def propagateWithinCond(cond: Tree)(implicit ctx: Context): Context = {
+    cond match {
+      case Select(lhs, op) if op == nme.ZAND || op == nme.ZOR =>
+        val Inferred(ifTrue, ifFalse) = FlowFacts.inferNonNull(lhs)
+        if (op == nme.ZAND) ctx.fresh.addNonNullFacts(ifTrue)
+        else ctx.fresh.addNonNullFacts(ifFalse)
+      case _ => ctx
+    }
+  }
+}