Fix NPEs revealed by tests

Author: noti0na1

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -205,7 +205,6 @@ class CompilationTests {
     ).checkCompile()
 
   // Explicit nulls tests
-  @Ignore
   @Test def explicitNullsNeg: Unit = {
     implicit val testGroup: TestGroup = TestGroup("explicitNullsNeg")
     aggregateTests(
@@ -215,7 +214,6 @@ class CompilationTests {
     )
   }.checkExpectedErrors()
 
-  @Ignore
   @Test def explicitNullsPos: Unit = {
     implicit val testGroup: TestGroup = TestGroup("explicitNullsPos")
     aggregateTests(
@@ -235,13 +233,11 @@ class CompilationTests {
     }
   }
 
-  @Ignore
   @Test def explicitNullsWarn: Unit = {
     implicit val testGroup: TestGroup = TestGroup("explicitNullsWarn")
     compileFilesInDir("tests/explicit-nulls/warn", explicitNullsOptions)
   }.checkWarnings()
 
-  @Ignore
   @Test def explicitNullsRun: Unit = {
     implicit val testGroup: TestGroup = TestGroup("explicitNullsRun")
     compileFilesInDir("tests/explicit-nulls/run", explicitNullsOptions)

library/src/scala/collection/immutable/RedBlackTree.scala

@@ -311,9 +311,9 @@ private[collection] object RedBlackTree {
     if (tree.right ne null) _foreachEntry(tree.right.nn, f)
   }
 
-  def iterator[A: Ordering, B](tree: Tree[A, B], start: Option[A] = None): Iterator[(A, B)] = new EntriesIterator(tree, start)
-  def keysIterator[A: Ordering](tree: Tree[A, _], start: Option[A] = None): Iterator[A] = new KeysIterator(tree, start)
-  def valuesIterator[A: Ordering, B](tree: Tree[A, B], start: Option[A] = None): Iterator[B] = new ValuesIterator(tree, start)
+  def iterator[A: Ordering, B](tree: Tree[A, B] | Null, start: Option[A] = None): Iterator[(A, B)] = new EntriesIterator(tree, start)
+  def keysIterator[A: Ordering](tree: Tree[A, _] | Null, start: Option[A] = None): Iterator[A] = new KeysIterator(tree, start)
+  def valuesIterator[A: Ordering, B](tree: Tree[A, B] | Null, start: Option[A] = None): Iterator[B] = new ValuesIterator(tree, start)
 
   @tailrec
   def nth[A, B](tree: Tree[A, B], n: Int): Tree[A, B] = {
@@ -927,16 +927,16 @@ private[collection] object RedBlackTree {
       equal && (this.lookahead eq null) && (that.lookahead eq null)
     }
   }
-  private[this] class EntriesIterator[A: Ordering, B](tree: Tree[A, B], focus: Option[A]) extends TreeIterator[A, B, (A, B)](tree, focus) {
-    override def nextResult(tree: Tree[A, B]) = (tree.key, tree.value)
+  private[this] class EntriesIterator[A: Ordering, B](tree: Tree[A, B] | Null, focus: Option[A]) extends TreeIterator[A, B, (A, B)](tree, focus) {
+    override def nextResult(tree: Tree[A, B]) = (tree.nn.key, tree.nn.value)
   }
 
-  private[this] class KeysIterator[A: Ordering, B](tree: Tree[A, B], focus: Option[A]) extends TreeIterator[A, B, A](tree, focus) {
-    override def nextResult(tree: Tree[A, B]) = tree.key
+  private[this] class KeysIterator[A: Ordering, B](tree: Tree[A, B] | Null, focus: Option[A]) extends TreeIterator[A, B, A](tree, focus) {
+    override def nextResult(tree: Tree[A, B]) = tree.nn.key
   }
 
-  private[this] class ValuesIterator[A: Ordering, B](tree: Tree[A, B], focus: Option[A]) extends TreeIterator[A, B, B](tree, focus) {
-    override def nextResult(tree: Tree[A, B]) = tree.value
+  private[this] class ValuesIterator[A: Ordering, B](tree: Tree[A, B] | Null, focus: Option[A]) extends TreeIterator[A, B, B](tree, focus) {
+    override def nextResult(tree: Tree[A, B]) = tree.nn.value
   }
 
   /** Build a Tree suitable for a TreeSet from an ordered sequence of keys */
@@ -1139,33 +1139,35 @@ private[collection] object RedBlackTree {
     else 2*bh-1
   }
 
-  private[this] def joinRight[A, B](tl: Tree[A, B], k: A, v: B, tr: Tree[A, B], bhtl: Int, rtr: Int): Tree[A, B] = {
+  private[this] def joinRight[A, B](tl: Tree[A, B] | Null, k: A, v: B, tr: Tree[A, B] | Null, bhtl: Int, rtr: Int): Tree[A, B] = {
     val rtl = rank(tl, bhtl)
     if(rtl == (rtr/2)*2) RedTree(k, v, tl, tr)
     else {
+      val tlnn = tl.nn
       val tlBlack = isBlackTree(tl)
       val bhtlr = if(tlBlack) bhtl-1 else bhtl
-      val ttr = joinRight(tl.right.nn, k, v, tr, bhtlr, rtr)
+      val ttr = joinRight(tlnn.right, k, v, tr, bhtlr, rtr)
       if(tlBlack && isRedTree(ttr) && isRedTree(ttr.right))
         RedTree(ttr.key, ttr.value,
-          BlackTree(tl.key, tl.value, tl.left, ttr.left),
+          BlackTree(tlnn.key, tlnn.value, tlnn.left, ttr.left),
           ttr.right.nn.black)
-      else mkTree(tlBlack, tl.key, tl.value, tl.left, ttr)
+      else mkTree(tlBlack, tlnn.key, tlnn.value, tlnn.left, ttr)
     }
   }
 
-  private[this] def joinLeft[A, B](tl: Tree[A, B], k: A, v: B, tr: Tree[A, B], rtl: Int, bhtr: Int): Tree[A, B] = {
+  private[this] def joinLeft[A, B](tl: Tree[A, B] | Null, k: A, v: B, tr: Tree[A, B] | Null, rtl: Int, bhtr: Int): Tree[A, B] = {
     val rtr = rank(tr, bhtr)
     if(rtr == (rtl/2)*2) RedTree(k, v, tl, tr)
     else {
+      val trnn = tr.nn
       val trBlack = isBlackTree(tr)
       val bhtrl = if(trBlack) bhtr-1 else bhtr
-      val ttl = joinLeft(tl, k, v, tr.left.nn, rtl, bhtrl)
+      val ttl = joinLeft(tl, k, v, trnn.left, rtl, bhtrl)
       if(trBlack && isRedTree(ttl) && isRedTree(ttl.left))
         RedTree(ttl.key, ttl.value,
           ttl.left.nn.black,
-          BlackTree(tr.key, tr.value, ttl.right, tr.right))
-      else mkTree(trBlack, tr.key, tr.value, ttl, tr.right)
+          BlackTree(trnn.key, trnn.value, ttl.right, trnn.right))
+      else mkTree(trBlack, trnn.key, trnn.value, ttl, trnn.right)
     }
   }
 
@@ -1175,7 +1177,7 @@ private[collection] object RedBlackTree {
     val bhtl = h(tl, 0)
     val bhtr = h(tr, 0)
     if(bhtl > bhtr) {
-      val tt = joinRight(tl.nn, k, v, tr.nn, bhtl, rank(tr, bhtr))
+      val tt = joinRight(tl.nn, k, v, tr.nn, bhtl, rank(tr, bhtr)) // todo: nullable
       if(isRedTree(tt) && isRedTree(tt.right)) tt.black
       else tt
     } else if(bhtr > bhtl) {

library/src/scala/collection/immutable/TreeMap.scala

@@ -87,15 +87,15 @@ final class TreeMap[K, +V] private (private val tree: RB.Tree[K, V] | Null)(impl
 
   override def sortedMapFactory: SortedMapFactory[TreeMap] = TreeMap
 
-  def iterator: Iterator[(K, V)] = RB.iterator(tree.nn)
+  def iterator: Iterator[(K, V)] = RB.iterator(tree)
 
-  def keysIteratorFrom(start: K): Iterator[K] = RB.keysIterator(tree.nn, Some(start))
+  def keysIteratorFrom(start: K): Iterator[K] = RB.keysIterator(tree, Some(start))
 
   override def keySet: TreeSet[K] = new TreeSet(tree)(ordering)
 
-  def iteratorFrom(start: K): Iterator[(K, V)] = RB.iterator(tree.nn, Some(start))
+  def iteratorFrom(start: K): Iterator[(K, V)] = RB.iterator(tree, Some(start))
 
-  override def valuesIteratorFrom(start: K): Iterator[V] = RB.valuesIterator(tree.nn, Some(start))
+  override def valuesIteratorFrom(start: K): Iterator[V] = RB.valuesIterator(tree, Some(start))
 
   override def stepper[S <: Stepper[_]](implicit shape: StepperShape[(K, V), S]): S with EfficientSplit =
     shape.parUnbox(

library/src/scala/collection/immutable/TreeSet.scala

@@ -130,9 +130,9 @@ final class TreeSet[A] private[immutable] (private[immutable] val tree: RB.Tree[
     if (v eq null) Option.empty else Some(v.key)
   }
 
-  def iterator: Iterator[A] = RB.keysIterator(tree.nn)
+  def iterator: Iterator[A] = RB.keysIterator(tree)
 
-  def iteratorFrom(start: A): Iterator[A] = RB.keysIterator(tree.nn, Some(start))
+  def iteratorFrom(start: A): Iterator[A] = RB.keysIterator(tree, Some(start))
 
   override def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, S]): S with EfficientSplit = {
     import scala.collection.convert.impl._

library/src/scala/collection/mutable/UnrolledBuffer.scala

@@ -264,7 +264,7 @@ object UnrolledBuffer extends StrictOptimizedClassTagSeqFactory[UnrolledBuffer]
 
   /** Unrolled buffer node.
     */
-  class Unrolled[T: ClassTag] private[collection] (var size: Int, var array: Array[T], var next: Unrolled[T] | Null, val buff: UnrolledBuffer[T] | Null) {
+  class Unrolled[T: ClassTag] private[collection] (var size: Int, var array: Array[T], var next: Unrolled[T] | Null, val buff: UnrolledBuffer[T] | Null = null) {
     this: Unrolled[T]^{} =>
     private[collection] def this() = this(0, new Array[T](unrolledlength), null, null)
     private[collection] def this(b: UnrolledBuffer[T] | Null) = this(0, new Array[T](unrolledlength), null, b)

library/src/scala/util/matching/Regex.scala

@@ -284,7 +284,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends
    *  @param  s     The string to match
    *  @return       The matches
    */
-  def unapplySeq(s: CharSequence): Option[List[String]] = {
+  def unapplySeq(s: CharSequence): Option[List[String | Null]] = {
     val m = pattern.matcher(s)
     if (runMatcher(m)) Some(List.tabulate(m.groupCount) { i => m.group(i + 1) })
     else None
@@ -338,7 +338,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends
    *  Otherwise, this Regex is applied to the previously matched input,
    *  and the result of that match is used.
    */
-  def unapplySeq(m: Match): Option[List[String]] =
+  def unapplySeq(m: Match): Option[List[String | Null]] =
     if (m.matched == null) None
     else if (m.matcher.pattern == this.pattern) Regex.extractGroupsFromMatch(m)
     else unapplySeq(m.matched.nn)
@@ -783,13 +783,13 @@ object Regex {
    *  }}}
    */
   object Groups {
-    def unapplySeq(m: Match): Option[Seq[String]] = {
+    def unapplySeq(m: Match): Option[Seq[String | Null]] = {
       if (m.groupCount > 0) extractGroupsFromMatch(m) else None
     }
   }
 
-  @inline private def extractGroupsFromMatch(m: Match): Option[List[String]] =
-     Some(List.tabulate(m.groupCount) { i => m.group(i + 1).nn })
+  @inline private def extractGroupsFromMatch(m: Match): Option[List[String | Null]] =
+     Some(List.tabulate(m.groupCount) { i => m.group(i + 1) })
 
   /** A class to step through a sequence of regex matches.
    *