Dotty with explicit nulls (and flow typing)

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