We have enabled the "Clean Block Closure" option for Pharo14
# What is this?
Until now, blocks are created at runtime, but there are blocks that actually do
not need any runtime data to be created.
Thus "Clean blocks" are those blocks that
- do not access self
- do not access instance variables (which needs self)
- do not return
- do not access temp variables from outer blocks or the method
With the clean block option enabled, the compiler can create the object at
compile time.
For Pharo12, we already enabled a sub-set: Constant Blocks. Now we do the next
step: pre-create *all* clean blocks.
# What is the effect?
Positive:
- much faster (we see a factor of 9 speedup for creating a block like
[1+2] )
- the resulting block does not reference the outer context / self
=> GC can cleanup more
- #isClean check on blocks is *much* faster (nice if you check for it
e.g. for serialization)
But:
This means that we now have blocks that have no outerContext and #receiver
returns nil.
All code that relies on these needs to be changed to take this into account.
We enabled Clean Blocks early in Pharo14 so we find all remaining problems,
especially related to external code.
So if you see strange behavior (especially in the debugger), please open an
issue on the issue tracker!
We are interested, too, in cases where you rely on either the receiver or the
outerContext for blocks in your own code.
# What next?
- Deprecate #receiver on BlockClosure
- Track down all remaining problems (e.g. debugger)
After:
- we want to enable to option to only reference the outerContext only
for those blocks that need it (that do a non-local return).
(there is a compiler option already, but disabled by default)
- only blocks that access self should hold onto the receiver
- .. and more
