Merge pull request #47 from noti0na1/dotty-explicit-nulls-notNull

Implement flow typing using nullability check; Update documents

Author: noti0na1

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

@@ -269,7 +269,7 @@ class Definitions {
     @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_typeCast: TermSymbol     = enterT1ParameterlessMethod(AnyClass, nme.asInstanceOfPM, _.paramRefs(0), Final | Synthetic | Artifact | StableRealizable)
-      // generated by pattern matcher, eliminated by erasure
+      // generated by pattern matcher and exlicit nulls, eliminated by erasure
 
     /** def getClass[A >: this.type](): Class[? <: A] */
     @tu lazy val Any_getClass: TermSymbol =

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

@@ -17,6 +17,7 @@ import SymDenotations._
 import Decorators._
 import Denotations._
 import Periods._
+import CheckRealizable._
 import util.Stats._
 import util.SimpleIdentitySet
 import reporting.diagnostic.Message
@@ -163,6 +164,9 @@ object Types {
       case tp: RefinedOrRecType => tp.parent.isStable
       case tp: ExprType => tp.resultType.isStable
       case tp: AnnotatedType => tp.parent.isStable
+      case tp: AndType =>
+        tp.tp1.isStable && (realizability(tp.tp2) eq Realizable) ||
+        tp.tp2.isStable && (realizability(tp.tp1) eq Realizable)
       case _ => false
     }
 

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

@@ -12,6 +12,7 @@ import Names._
 import StdNames._
 import Contexts._
 import Nullables.{CompareNull, TrackedRef}
+import NullOpsDecorator._
 
 object ConstFold {
 
@@ -20,10 +21,6 @@ object ConstFold {
   /** If tree is a constant operation, replace with result. */
   def apply[T <: Tree](tree: T)(implicit ctx: Context): T = finish(tree) {
     tree match {
-      case CompareNull(TrackedRef(ref), testEqual)
-      if ctx.settings.YexplicitNulls.value && ctx.notNullInfos.impliesNotNull(ref) =>
-        // TODO maybe drop once we have general Nullability?
-        Constant(!testEqual)
       case Apply(Select(xt, op), yt :: Nil) =>
         xt.tpe.widenTermRefExpr.normalized match
           case ConstantType(x) =>

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

@@ -10,6 +10,7 @@ import util.Property
 import Names.Name
 import util.Spans.Span
 import Flags.Mutable
+import NullOpsDecorator._
 import collection.mutable
 
 /** Operations for implementing a flow analysis for nullability */
@@ -104,13 +105,57 @@ object Nullables with
    *  This is the case if the reference is a path to an immutable val, or if it refers
    *  to a local mutable variable where all assignments to the variable are _reachable_
    *  (in the sense of how it is defined in assignmentSpans).
+   *
+   *  When dealing with local mutable variables, there are two questions:
+   *
+   *  1. Whether to track a local mutable variable during flow typing.
+   *    We track a local mutable variable iff the variable is not assigned in a closure.
+   *    For example, in the following code `x` is assigned to by the closure `y`, so we do not
+   *    do flow typing on `x`.
+   *    ```scala
+   *    var x: String|Null = ???
+   *    def y = {
+   *      x = null
+   *    }
+   *    if (x != null) {
+   *      // y can be called here, which break the fact
+   *      val a: String = x // error: x is captured and mutated by the closure, not tackable
+   *    }
+   *    ```
+   *
+   *  2. Whether to generate and use flow typing on a specific _use_ of a local mutable variable.
+   *    We only want to do flow typing on a use that belongs to the same method as the definition
+   *    of the local variable.
+   *    For example, in the following code, even `x` is not assigned to by a closure, but we can only
+   *    use flow typing in one of the occurrences (because the other occurrence happens within a nested
+   *    closure).
+   *    ```scala
+   *    var x: String|Null = ???
+   *    def y = {
+   *      if (x != null) {
+   *        // not safe to use the fact (x != null) here
+   *        // since y can be executed at the same time as the outer block
+   *        val _: String = x
+   *      }
+   *    }
+   *    if (x != null) {
+   *      val a: String = x // ok to use the fact here
+   *      x = null
+   *    }
+   *    ```
+   *
+   *  See more examples in `tests/explicit-nulls/neg/var-ref-in-closure.scala`.
    */
   def isTracked(ref: TermRef)(given Context) =
     ref.isStable
     || { val sym = ref.symbol
          sym.is(Mutable)
          && sym.owner.isTerm
-         && sym.owner.enclosingMethod == curCtx.owner.enclosingMethod
+         && ( sym.owner == curCtx.owner
+          || !curCtx.owner.is(Flags.Lazy) // not at the rhs of lazy ValDef
+            && sym.owner.enclosingMethod == curCtx.owner.enclosingMethod // not in different methods
+            // TODO: need to check by-name paramter
+          )
          && sym.span.exists
          && curCtx.compilationUnit != null // could be null under -Ytest-pickler
          && curCtx.compilationUnit.assignmentSpans.contains(sym.span.start)
@@ -254,7 +299,13 @@ object Nullables with
   given assignOps: (tree: Assign)
     def computeAssignNullable()(given Context): tree.type = tree.lhs match
       case TrackedRef(ref) =>
-        tree.withNotNullInfo(NotNullInfo(Set(), Set(ref))) // TODO: refine with nullability type info
+        val rhstp = tree.rhs.typeOpt
+        if (rhstp.isNullType || (curCtx.explicitNulls && rhstp.isNullableUnion))
+          // If the type of rhs is nullable (`T|Null` or `Null`), then the nullability of the
+          // lhs variable is no longer trackable. We don't need to check whether the type `T`
+          // is correct here, as typer will check it.
+          tree.withNotNullInfo(NotNullInfo(Set(), Set(ref)))
+        else tree
       case _ => tree
 
   private val analyzedOps = Set(nme.EQ, nme.NE, nme.eq, nme.ne, nme.ZAND, nme.ZOR, nme.UNARY_!)

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

@@ -41,6 +41,7 @@ import transform.SymUtils._
 import transform.TypeUtils._
 import reporting.trace
 import Nullables.{NotNullInfo, given}
+import NullOpsDecorator._
 
 object Typer {
 
@@ -347,6 +348,16 @@ class Typer extends Namer
     findRefRecur(NoType, BindingPrec.NothingBound, NoContext)
   }
 
+  // If `tree`'s type is a `TermRef` identified by flow typing to be non-null, then
+  // cast away `tree`s nullability. Otherwise, `tree` remains unchanged.
+  def toNotNullTermRef(tree: Tree, pt: Type)(implicit ctx: Context): Tree = tree.tpe match
+    case ref @ OrNull(tpnn) : TermRef
+    if pt != AssignProto && // Ensure it is not the lhs of Assign
+    ctx.notNullInfos.impliesNotNull(ref) =>
+      tree.select(defn.Any_typeCast).appliedToType(AndType(ref, tpnn))
+    case _ =>
+      tree
+
   /** Attribute an identifier consisting of a simple name or wildcard
    *
    *  @param tree      The tree representing the identifier.
@@ -417,7 +428,9 @@ class Typer extends Namer
         tree.withType(ownType)
     }
 
-    checkStableIdentPattern(tree1, pt)
+    val tree2 = toNotNullTermRef(tree1, pt)
+
+    checkStableIdentPattern(tree2, pt)
   }
 
   /** Check that a stable identifier pattern is indeed stable (SLS 8.1.5)
@@ -442,8 +455,11 @@ class Typer extends Namer
     case qual =>
       if (tree.name.isTypeName) checkStable(qual.tpe, qual.sourcePos)
       val select = assignType(cpy.Select(tree)(qual, tree.name), qual)
-      if (select.tpe ne TryDynamicCallType) ConstFold(checkStableIdentPattern(select, pt))
-      else if (pt.isInstanceOf[FunOrPolyProto] || pt == AssignProto) select
+
+      val select1 = toNotNullTermRef(select, pt)
+
+      if (select1.tpe ne TryDynamicCallType) ConstFold(checkStableIdentPattern(select1, pt))
+      else if (pt.isInstanceOf[FunOrPolyProto] || pt == AssignProto) select1
       else typedDynamicSelect(tree, Nil, pt)
   }
 
@@ -1554,16 +1570,6 @@ class Typer extends Namer
     typed(annot, defn.AnnotationClass.typeRef)
 
   def typedValDef(vdef: untpd.ValDef, sym: Symbol)(implicit ctx: Context): Tree = {
-    sym.infoOrCompleter match
-      case completer: Namer#Completer
-      if completer.creationContext.notNullInfos ne ctx.notNullInfos =>
-        // The RHS of a val def should know about not null facts established
-        // in preceding statements (unless the ValDef is completed ahead of time,
-        // then it is impossible).
-        vdef.symbol.info = Completer(completer.original)(
-          given completer.creationContext.withNotNullInfos(ctx.notNullInfos))
-      case _ =>
-
     val ValDef(name, tpt, _) = vdef
     completeAnnotations(vdef, sym)
     if (sym.isOneOf(GivenOrImplicit)) checkImplicitConversionDefOK(sym)
@@ -2216,14 +2222,31 @@ class Typer extends Namer
           case Some(xtree) =>
             traverse(xtree :: rest)
           case none =>
-            val defCtx = mdef match
+            def defCtx = ctx.withNotNullInfos(initialNotNullInfos)
+            val newCtx = if (ctx.owner.isTerm) {
               // Keep preceding not null facts in the current context only if `mdef`
               // cannot be executed out-of-sequence.
-              case _: ValDef if !mdef.mods.is(Lazy) && ctx.owner.isTerm =>
-                ctx // all preceding statements will have been executed in this case
-              case _ =>
-                ctx.withNotNullInfos(initialNotNullInfos)
-            typed(mdef)(given defCtx) match {
+              // We have to check the Completer of symbol befor typedValDef,
+              // otherwise the symbol is already completed using creation context.
+              mdef.getAttachment(SymOfTree).map(s => (s, s.infoOrCompleter)) match {
+                case Some((sym, completer: Namer#Completer)) =>
+                  if (completer.creationContext.notNullInfos ne ctx.notNullInfos)
+                    // The RHS of a val def should know about not null facts established
+                    // in preceding statements (unless the DefTree is completed ahead of time,
+                    // then it is impossible).
+                    sym.info = Completer(completer.original)(
+                      given completer.creationContext.withNotNullInfos(ctx.notNullInfos))
+                  ctx // all preceding statements will have been executed in this case
+                case _ =>
+                  // If it has been completed, then it must be because there is a forward reference
+                  // to the definition in the program. Hence, we don't Keep preceding not null facts
+                  // in the current context.
+                  defCtx
+              }
+            }
+            else defCtx
+
+            typed(mdef)(given newCtx) match {
               case mdef1: DefDef if !Inliner.bodyToInline(mdef1.symbol).isEmpty =>
                 buf += inlineExpansion(mdef1)
                   // replace body with expansion, because it will be used as inlined body