Locals clearing + forcing a delay recursively results in NPE

Thu, 30 May 2024 21:11:28 +0000

Discovered by Ambrose Bonnaire-Sergeant (@ambrosebs).

Given this convoluted example:

(let [f +
      p (promise)
      d (delay (f) @@p)]
 (deliver p d)
 @d)

When executed, it fails with:

1. Unhandled java.lang.NullPointerException
   Cannot invoke "clojure.lang.IFn.invoke()" because "this.f" is null

The same error happens with lazy seqs:

(let [f +
      p (promise)
      d (lazy-seq (f) (first @p))]
  (deliver p d)
  (first d))

The reason in both cases is that locals clearing assigns this.f = null; right after it is first invoked, so when the recursive call reaches (f) again, the reference is already nil.

(binding [*compiler-options* {:disable-locals-clearing false}]
  (clj-java-decompiler.core/decompile
   (defn repro []
     (let [f +
        p (promise)
        d (delay (f) @@p)]
    (deliver p d)
    @d))))

=>

@Override
public Object invoke() {
    final Object f = this.f;
    this.f = null;
    ((IFn)f).invoke();
    final IFn fn = (IFn)__deref.getRawRoot();
    final IFn fn2 = (IFn)__deref.getRawRoot();
    final Object p = this.p;
    this.p = null;
    final Object invoke = fn2.invoke(p);
    this = null;
    return fn.invoke(invoke);
}

Is this a bug or undefined behavior?

lazy-seq in ClojureScript does not allow for self-referential sequences

Wed, 20 Apr 2022 21:02:56 +0000

For context, started on Slack at https://clojurians.slack.com/archives/C03S1L9DN/p1650480331191719

This code works just fine on CLJ but fails with StackOverflowError on CLJS:

(def primes (remove
             (fn [x]
               (some #(zero? (mod x %)) primes))
             (iterate inc 2)))

The vital difference between CLJ and CLJS in this case is that in the former, lazy-seq ends up wrapping its whole body in a function with ^:once.

The reasoning why it works that way is because in the code above, the inner primes is a closed over value, it becomes a local. When the body fn of a lazy-seq (the one with ^:once) is called the second time, its locals are nil, so that inner primes is also nil. And iteration stops.
In CLJS, there's no :once and no locals clearing, so the inner primes is never nil, and the execution keeps on going into that fn without even calling that zero?.

Even if the reasoning doesn't sound plausible, the hypothesis that it's indeed :once that's to blame for the difference can be easily confirmed by implementing lazy-seq in CLJ without :once and noticing that it leads to StackOverflowError.

It's unclear to me what to do in this case, but perhaps at least a note on the https://clojurescript.org/about/differences page should be made about it.

Clojure Q&A - Recent questions tagged locals clearing

Locals clearing + forcing a delay recursively results in NPE

lazy-seq in ClojureScript does not allow for self-referential sequences