If Yes the value is known to always be null at runtime. In this case the upper bound is (has to be) empty. If the answer is Unknown then the analysis was not able to statically determine whether the value is null or is not null. In this case the upper bound is expected to be non-empty. If the answer is No then the value is statically known not to be null. In this case, the upper bound may precisely identify the runtime type or still just identify an upper bound.

The least upper type bound of the value.

None if and only if the underlying value is null.

All types from which the (precise, but unknown) type of the represented value inherits. I.e., the value represented by this domain value is known to have a type that (in)directly inherits from all given types at the same time. Hence, the upperTypeBound may contain at most one class type.

The set of base values (IsReferenceValue) this value abstracts over. This set is never empty and contains this value if this value does not (further) abstract over other reference values; otherwise it only contains the base values, but not this value.

Returns the type of the upper type bound if the upper type bound contains exactly one element. That is, the function is only always defined iff the type is precise.

In general an IsReferenceValue abstracts over all potential values and this information is sufficient for subsequent analyses; but in some cases, analyzing the set of underlying values may increase the overall precision and this set is returned by this function. In other words: if baseValues is nonEmpty, then the properties returned by this value are derived from the base values, but still maybe more specific. For example,

Object o = _;
if(...) o = f() else o = g();
// when we reach this point, we generally don't know if the values returned by f and g
// are non-null; hence, o is potentially null.
if(o != null)
 // Now, we know that o is not null, but we still don't know if the values returned
 // by f OR g were null and we cannot establish that when we don't know to which value
 // o is actually referring to.
 u(o);

The computational type of the value if this object represents a legal value.

The precise computational type is, e.g., needed to calculate the effect of generic stack manipulation instructions (e.g., DUP_... and SWAP) on the stack as well as to calculate the jump targets of RET instructions and to determine which values are actually copied by, e.g., the dup_XX instructions.

Returns true if and only if the value has the computational type 2; false in all other cases (including the case where this value is illegal!).

Returns Yes if the value is _not null_ and the least upper type bound is an ArrayType; the value is Unknown if the least upper type bound is ArrayType but the value may be null; in all other cases No is returned; in particular if the value is known to be null. No is also returned if the value's type is Object or Seriablizable or Cloneable.

Returns true iff this value is not a legal value according to the JVM specification. Such values cannot be used to perform any computations and will generally not occur in static analyses unless the analysis or the bytecode is buggy.

Returns true if the type information is precise. I.e., the type returned by upperTypeBound precisely models the runtime type of the value. If, isPrecise returns true, the type of this value can generally be assumed to represent a class type (not an interface type) or an array type. However, this domain also supports the case that isPrecise returns true even though the associated type identifies an interface type or an abstract class type. The later case may be interesting in the context of classes that are generated at run time.

Returns true in case of a value with primitive type.

Returns true if the value has a reference type.

Determines if this value is a subtype of the given supertype by delegating to the isSubtypeOf(ReferenceType,ReferenceType) method of the domain.

Returns true if this value represents void.

Returns a ValueInformation object that just captures the basic information as defined by this value framework. The returned value information object will be independent of the underlying representation from which it was derived.

The type of this value as used by the org.opalj.br.StackMapTable attribute.