@SubtypeOf(value={}) @DefaultFor(value={LOCAL_VARIABLE,RESOURCE_VARIABLE}) @Documented @Retention(value=RUNTIME) @Target(value={TYPE_USE,TYPE_PARAMETER}) public @interface Raw
NullnessRawnessChecker uses rawness to track
initialization of NonNull fields.
This type qualifier indicates that the object might not have been fully initialized. An object
is fully initialized when each of its fields contains a value that satisfies its type qualifier.
What type qualifiers are considered depends on the checker; for instance, the NullnessRawnessChecker considers NonNull.
Therefore, reading a field of an object of type Raw might yield a value that does not
correspond to the declared type qualifier for that field. For instance, in the NullnessRawnessChecker, a field might be null even
if it has been annotated as NonNull.
More precisely, an expression of type @Raw(T.class) refers to an object that has all
fields of T (and any super-classes) initialized (e.g., to a non-null value in the NullnessRawnessChecker). Just @Raw is equivalent
to @Raw(Object.class).
At the beginning of a constructor, the fields of the object are not yet initialized and thus
Raw(supertype) is used as the type of the self-reference this.
Consider a class B that is a subtype of A. At the beginning of the constructor of
B, this has the type @Raw(A.class), since all fields of A have
been initialized by the super-constructor. If during the constructor also all fields of B
are initialized, then the type of this changes to @Raw(B.class) (and otherwise,
if not all fields are initialized, an error is issued).
At the end of the constructor, the type is not fully initialized. Rather, it is Raw(<em>supertype</em>).
Note that it would not be sound to type this as NonRaw anywhere in a
constructor (with the exception of final classes; but this is currently not implemented), because
there might be subclasses with uninitialized fields. The following example shows why:
class A {
@NonNull String a;
public A() {
a = "";
// Now, all fields of A are initialized.
// However, if this constructor is invoked as part of 'new B()', then
// the fields of B are not yet initialized.
// If we would type 'this' as @NonRaw, then the following call is valid:
foo();
}
void foo() {}
}
class B extends A {
@NonNull String b;
@Override
void foo() {
// Dereferencing 'b' is ok, since 'this' is @NonRaw and 'b' @NonNull.
// However, when executing 'new B()', this line throws a null-pointer exception.
b.toString();
}
}
public abstract Class<?> value
@Raw(T.class) has all type-frames
initialized starting at Object down to (and including) T.