public abstract class ImmutableLiteral
Operands extending this type can make a reasonable assumption of
immutability. In Ruby, almost nothing is truly immutable (set_instance_var)
but for the sake of our compiler we can assume the basic behavior will
continue to work unchanged (the value of an instance of fixnum 3 will remain
Knowing that we have a literal which will not change can be used for
optimizations like constant propagation.
ENEBO: This cachedObject thing obviously cannot be used from multiple
threads without some safety being added. This probably also is not the
fastest code, but it is very simple. It would be really nice to make this
side-effect free as well, but this is difficult without adding a level of
indirection or pre-caching each value we encounter during construction.
Fields inherited from class org.jruby.ir.operands.Operand
Can we replace every use of a variable 'v' that contains the value of this operand
with the operand itself? This takes importance when there are at least two uses
of 'v' within this scope.
Ex: v = [1,2,3]; x = v; y = v
In this case, we cannot replace the occurences of 'v' because we would then get
x = [1,2,3]; y = [1,2,3] which would then result in two different array objects
being constructed instead of a single one.
retrieve the live value represented by this immutable literal. An
interesting property of knowing something cannot change at compile
time is that all information neccesary to construct it is also known
at compile time. We don't pre-create these since we don't want to
assume the cost of constructing literals which may never be used.