Show that @nullout works as intended

lrytz · lrytz · commit 8f785ec47f6c · 2024-12-18T17:27:07.000+01:00
Needs a restarr to work!

The forwarder / alias `IterableOnceOps./:` uses `@nullOut` to clear
the `this` reference before calling `foldLeft`. The annotation is
also on the method itself to ensure mixin forwarders (generated in
the subclass) and the static mixin accessor (generated in the trait)
null out the receiver before invoking `/:`.

After removing `LazyList.foldLeft`, it inherits the implementation
from LinearSeqOps. That method again uses `@nullOut` twice, once
to clear `this` when it's no longer needed, and once on the method
for the generated accessors.

I think we should *not* use `@nullOut` everywhere in the standard
library, only on methods that cannot be overridden in LazyList, like
`/:`.

`@nullOut` works correctly on `mkString` too, but unfortunately the
`addString` override in LazyList prevents GC of processed elements
due to cycle detection.
diff --git a/src/library/scala/collection/IterableOnce.scala b/src/library/scala/collection/IterableOnce.scala
@@ -755,7 +755,8 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
   def foldRight[B](z: B)(op: (A, B) => B): B = reversed.foldLeft(z)((b, a) => op(a, b))
 
   @deprecated("Use foldLeft instead of /:", "2.13.0")
-  @`inline` final def /: [B](z: B)(op: (B, A) => B): B = foldLeft[B](z)(op)
+  @annotation.nullOut
+  @`inline` final def /: [B](z: B)(op: (B, A) => B): B = (this: @annotation.nullOut).foldLeft[B](z)(op)
 
   @deprecated("Use foldRight instead of :\\", "2.13.0")
   @`inline` final def :\ [B](z: B)(op: (A, B) => B): B = foldRight[B](z)(op)
@@ -1313,9 +1314,10 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
    *
    *  @example  `List(1, 2, 3).mkString("(", "; ", ")") = "(1; 2; 3)"`
    */
+  @annotation.nullOut
   final def mkString(start: String, sep: String, end: String): String =
     if (knownSize == 0) start + end
-    else addString(new StringBuilder(), start, sep, end).result()
+    else (this: @annotation.nullOut).addString(new StringBuilder(), start, sep, end).result()
 
   /** Displays all elements of this $coll in a string using a separator string.
    *
@@ -1328,7 +1330,8 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
    *
    *  @example  `List(1, 2, 3).mkString("|") = "1|2|3"`
    */
-  @inline final def mkString(sep: String): String = mkString("", sep, "")
+  @annotation.nullOut
+  @inline final def mkString(sep: String): String = (this: @annotation.nullOut).mkString("", sep, "")
 
   /** Displays all elements of this $coll in a string.
    *
@@ -1339,7 +1342,8 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
    *          of all elements of this $coll follow each other without any
    *          separator string.
    */
-  @inline final def mkString: String = mkString("")
+  @annotation.nullOut
+  @inline final def mkString: String = (this: @annotation.nullOut).mkString("")
 
   /** Appends all elements of this $coll to a string builder using start, end, and separator strings.
    *  The written text begins with the string `start` and ends with the string `end`.
@@ -1365,10 +1369,11 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
    *  @param end   the ending string.
    *  @return      the string builder `b` to which elements were appended.
    */
+  @annotation.nullOut
   def addString(b: StringBuilder, start: String, sep: String, end: String): b.type = {
     val jsb = b.underlying
     if (start.length != 0) jsb.append(start)
-    val it = iterator
+    val it = (this: @annotation.nullOut).iterator
     if (it.hasNext) {
       jsb.append(it.next())
       while (it.hasNext) {
diff --git a/src/library/scala/collection/LinearSeq.scala b/src/library/scala/collection/LinearSeq.scala
@@ -176,9 +176,10 @@ trait LinearSeqOps[+A, +CC[X] <: LinearSeq[X], +C <: LinearSeq[A] with LinearSeq
     None
   }
 
+  @annotation.nullOut
   override def foldLeft[B](z: B)(op: (B, A) => B): B = {
     var acc = z
-    var these: LinearSeq[A] = coll
+    var these: LinearSeq[A] = (this: @annotation.nullOut).coll
     while (!these.isEmpty) {
       acc = op(acc, these.head)
       these = these.tail
diff --git a/src/library/scala/collection/immutable/LazyList.scala b/src/library/scala/collection/immutable/LazyList.scala
@@ -416,19 +416,6 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () =>
     }
   }
 
-  /** LazyList specialization of foldLeft which allows GC to collect along the
-    * way.
-    *
-    * @tparam B The type of value being accumulated.
-    * @param z The initial value seeded into the function `op`.
-    * @param op The operation to perform on successive elements of the `LazyList`.
-    * @return The accumulated value from successive applications of `op`.
-    */
-  @tailrec
-  override def foldLeft[B](z: B)(op: (B, A) => B): B =
-    if (isEmpty) z
-    else tail.foldLeft(op(z, head))(op)
-
   // LazyList.Empty doesn't use the SerializationProxy
   protected[this] def writeReplace(): AnyRef =
     if (knownNonEmpty) new SerializationProxy[A](this) else this
diff --git a/test/junit/scala/collection/immutable/LazyListGCTest.scala b/test/junit/scala/collection/immutable/LazyListGCTest.scala
@@ -117,9 +117,8 @@ class LazyListGCTest {
     assertLazyListOpAllowsGC((ll, check) => ll.tails.zipWithIndex.foreach { case (_, i) => check(i) }, _ => ())
   }
 
-  @Test
+  @Test @annotation.nowarn("cat=deprecation")
   def foldLeft(): Unit = {
-    // fails when using `/:` instead of `foldLeft`
-    assertLazyListOpAllowsGC((ll, check) => ll.foldLeft(0){ case (s, x) => check(x); s + x}, _ => ())
+    assertLazyListOpAllowsGC((ll, check) => ll./:(0){ case (s, x) => check(x); s + x}, _ => ())
   }
 }

Original file line number	Diff line number	Diff line change
`@@ -117,9 +117,8 @@ class LazyListGCTest {`
`117`	`117`	`assertLazyListOpAllowsGC((ll, check) => ll.tails.zipWithIndex.foreach { case (_, i) => check(i) }, _ => ())`
`118`	`118`	`}`
`119`	`119`
`120`		`- @Test`
	`120`	`+ @Test @annotation.nowarn("cat=deprecation")`
`121`	`121`	`def foldLeft(): Unit = {`
`122`		- // fails when using `/:` instead of `foldLeft`
`123`		`- assertLazyListOpAllowsGC((ll, check) => ll.foldLeft(0){ case (s, x) => check(x); s + x}, _ => ())`
	`122`	`+ assertLazyListOpAllowsGC((ll, check) => ll./:(0){ case (s, x) => check(x); s + x}, _ => ())`
`124`	`123`	`}`
`125`	`124`	`}`