/* This method replaces the version that used to sit in LE. The parameter `annotations' is a flattened sequence of annotations,
where each dimension's annotations end with a sentinel null. Leaf type can be an already annotated type.
See ArrayBinding.swapUnresolved for further special case handling if incoming leafType is a URB that would resolve to a raw
type later.
*/
public ArrayBinding getArrayType(
TypeBinding leafType, int dimensions, AnnotationBinding[] annotations) {
ArrayBinding nakedType = null;
TypeBinding[] derivedTypes = getDerivedTypes(leafType);
for (int i = 0, length = derivedTypes.length; i < length; i++) {
TypeBinding derivedType = derivedTypes[i];
if (derivedType == null) break;
if (!derivedType.isArrayType()
|| derivedType.dimensions() != dimensions
|| derivedType.leafComponentType() != leafType) // $IDENTITY-COMPARISON$
continue;
if (Util.effectivelyEqual(derivedType.getTypeAnnotations(), annotations))
return (ArrayBinding) derivedType;
if (!derivedType.hasTypeAnnotations()) nakedType = (ArrayBinding) derivedType;
}
if (nakedType == null) nakedType = super.getArrayType(leafType, dimensions);
if (!haveTypeAnnotations(leafType, annotations)) return nakedType;
ArrayBinding arrayType = new ArrayBinding(leafType, dimensions, this.environment);
arrayType.id = nakedType.id;
arrayType.setTypeAnnotations(annotations, this.isAnnotationBasedNullAnalysisEnabled);
return (ArrayBinding) cacheDerivedType(leafType, nakedType, arrayType);
}
public RawTypeBinding getRawType(
ReferenceBinding genericType,
ReferenceBinding enclosingType,
AnnotationBinding[] annotations) {
if (genericType.hasTypeAnnotations()) throw new IllegalStateException();
RawTypeBinding nakedType = null;
TypeBinding[] derivedTypes = getDerivedTypes(genericType);
for (int i = 0, length = derivedTypes.length; i < length; i++) {
TypeBinding derivedType = derivedTypes[i];
if (derivedType == null) break;
if (!derivedType.isRawType()
|| derivedType.actualType() != genericType
|| derivedType.enclosingType() != enclosingType) // $IDENTITY-COMPARISON$
continue;
if (Util.effectivelyEqual(derivedType.getTypeAnnotations(), annotations))
return (RawTypeBinding) derivedType;
if (!derivedType.hasTypeAnnotations()) nakedType = (RawTypeBinding) derivedType;
}
if (nakedType == null) nakedType = super.getRawType(genericType, enclosingType);
if (!haveTypeAnnotations(genericType, enclosingType, null, annotations)) return nakedType;
RawTypeBinding rawType = new RawTypeBinding(genericType, enclosingType, this.environment);
rawType.id = nakedType.id;
rawType.setTypeAnnotations(annotations, this.isAnnotationBasedNullAnalysisEnabled);
return (RawTypeBinding) cacheDerivedType(genericType, nakedType, rawType);
}
public WildcardBinding getWildcard(
ReferenceBinding genericType,
int rank,
TypeBinding bound,
TypeBinding[] otherBounds,
int boundKind,
AnnotationBinding[] annotations) {
if (genericType == null) // pseudo wildcard denoting composite bounds for lub computation
genericType = ReferenceBinding.LUB_GENERIC;
if (genericType.hasTypeAnnotations()) throw new IllegalStateException();
WildcardBinding nakedType = null;
TypeBinding[] derivedTypes = getDerivedTypes(genericType);
for (int i = 0, length = derivedTypes.length; i < length; i++) {
TypeBinding derivedType = derivedTypes[i];
if (derivedType == null) break;
if (!derivedType.isWildcard()
|| derivedType.actualType() != genericType
|| derivedType.rank() != rank) // $IDENTITY-COMPARISON$
continue;
if (derivedType.boundKind() != boundKind
|| derivedType.bound() != bound
|| !Util.effectivelyEqual(
derivedType.additionalBounds(), otherBounds)) // $IDENTITY-COMPARISON$
continue;
if (Util.effectivelyEqual(derivedType.getTypeAnnotations(), annotations))
return (WildcardBinding) derivedType;
if (!derivedType.hasTypeAnnotations()) nakedType = (WildcardBinding) derivedType;
}
if (nakedType == null)
nakedType = super.getWildcard(genericType, rank, bound, otherBounds, boundKind);
if (!haveTypeAnnotations(genericType, bound, otherBounds, annotations)) return nakedType;
WildcardBinding wildcard =
new WildcardBinding(genericType, rank, bound, otherBounds, boundKind, this.environment);
wildcard.id = nakedType.id;
wildcard.setTypeAnnotations(annotations, this.isAnnotationBasedNullAnalysisEnabled);
return (WildcardBinding) cacheDerivedType(genericType, nakedType, wildcard);
}
/* Private subroutine for public APIs. Create an annotated version of the type. To materialize the annotated version, we can't use new since
this is a general purpose method designed to deal type bindings of all types. "Clone" the incoming type, specializing for any enclosing type
that may itself be possibly be annotated. This is so the binding for @Outer Outer.Inner != Outer.@Inner Inner != @Outer Outer.@Inner Inner.
Likewise so the bindings for @Readonly List<@NonNull String> != @Readonly List<@Nullable String> != @Readonly List<@Interned String>
*/
private TypeBinding getAnnotatedType(
TypeBinding type, TypeBinding enclosingType, AnnotationBinding[] annotations) {
if (type.kind() == Binding.PARAMETERIZED_TYPE) {
return getParameterizedType(
type.actualType(), type.typeArguments(), (ReferenceBinding) enclosingType, annotations);
}
TypeBinding nakedType = null;
TypeBinding[] derivedTypes = getDerivedTypes(type);
for (int i = 0, length = derivedTypes.length; i < length; i++) {
TypeBinding derivedType = derivedTypes[i];
if (derivedType == null) break;
if (derivedType.enclosingType() != enclosingType
|| !Util.effectivelyEqual(
derivedType.typeArguments(), type.typeArguments())) // $IDENTITY-COMPARISON$
continue;
switch (type.kind()) {
case Binding.ARRAY_TYPE:
if (!derivedType.isArrayType()
|| derivedType.dimensions() != type.dimensions()
|| derivedType.leafComponentType()
!= type.leafComponentType()) // $IDENTITY-COMPARISON$
continue;
break;
case Binding.RAW_TYPE:
if (!derivedType.isRawType()
|| derivedType.actualType() != type.actualType()) // $IDENTITY-COMPARISON$
continue;
break;
case Binding.WILDCARD_TYPE:
if (!derivedType.isWildcard()
|| derivedType.actualType() != type.actualType()
|| derivedType.rank() != type.rank()
|| derivedType.boundKind() != type.boundKind()) // $IDENTITY-COMPARISON$
continue;
if (derivedType.bound() != type.bound()
|| !Util.effectivelyEqual(
derivedType.additionalBounds(), type.additionalBounds())) // $IDENTITY-COMPARISON$
continue;
break;
default:
switch (derivedType.kind()) {
case Binding.ARRAY_TYPE:
case Binding.RAW_TYPE:
case Binding.WILDCARD_TYPE:
case Binding.INTERSECTION_CAST_TYPE:
case Binding.INTERSECTION_TYPE:
continue;
}
break;
}
if (Util.effectivelyEqual(derivedType.getTypeAnnotations(), annotations)) {
return derivedType;
}
if (!derivedType.hasTypeAnnotations()) nakedType = derivedType;
}
if (nakedType == null) nakedType = getUnannotatedType(type);
if (!haveTypeAnnotations(type, enclosingType, null, annotations)) return nakedType;
TypeBinding annotatedType = type.clone(enclosingType);
annotatedType.id = nakedType.id;
annotatedType.setTypeAnnotations(annotations, this.isAnnotationBasedNullAnalysisEnabled);
TypeBinding keyType;
switch (type.kind()) {
case Binding.ARRAY_TYPE:
keyType = type.leafComponentType();
break;
case Binding.RAW_TYPE:
case Binding.WILDCARD_TYPE:
keyType = type.actualType();
break;
default:
keyType = nakedType;
break;
}
return cacheDerivedType(keyType, nakedType, annotatedType);
}
/* Take a type and apply annotations to various components of it. By construction when we see the type reference @Outer Outer.@Middle Middle.@Inner Inner,
we first construct the binding for Outer.Middle.Inner and then annotate various parts of it. Likewise for PQTR's binding.
*/
public TypeBinding getAnnotatedType(TypeBinding type, AnnotationBinding[][] annotations) {
if (type == null || !type.isValidBinding() || annotations == null || annotations.length == 0)
return type;
TypeBinding annotatedType = null;
switch (type.kind()) {
case Binding.ARRAY_TYPE:
ArrayBinding arrayBinding = (ArrayBinding) type;
annotatedType =
getArrayType(
arrayBinding.leafComponentType,
arrayBinding.dimensions,
flattenedAnnotations(annotations));
break;
case Binding.BASE_TYPE:
case Binding.TYPE:
case Binding.GENERIC_TYPE:
case Binding.PARAMETERIZED_TYPE:
case Binding.RAW_TYPE:
case Binding.TYPE_PARAMETER:
case Binding.WILDCARD_TYPE:
case Binding.INTERSECTION_TYPE:
case Binding.INTERSECTION_CAST_TYPE:
/* Taking the binding of QTR as an example, there could be different annotatable components, but we come in a with a single binding, e.g:
@T Z; type => Z annotations => [[@T]]
@T Y.@T Z type => Z annotations => [[@T][@T]]
@T X.@T Y.@T Z type => Z annotations => [[@T][@T][@T]]
java.lang.@T X.@T Y.@T Z type => Z annotations => [[][][@T][@T][@T]]
in all these cases the incoming type binding is for Z, but annotations are for different levels. We need to align their layout for proper attribution.
*/
if (type.isUnresolvedType() && CharOperation.indexOf('$', type.sourceName()) > 0)
type =
BinaryTypeBinding.resolveType(
type,
this.environment,
true); // must resolve member types before asking for enclosingType
int levels = type.depth() + 1;
TypeBinding[] types = new TypeBinding[levels];
types[--levels] = type;
TypeBinding enclosingType = type.enclosingType();
while (enclosingType != null) {
types[--levels] = enclosingType;
enclosingType = enclosingType.enclosingType();
}
// Locate the outermost type being annotated. Beware annotations.length could be >
// types.length (for package qualified names in QTR/PQTR)
levels = annotations.length;
int i, j = types.length - levels;
for (i = 0; i < levels; i++, j++) {
if (annotations[i] != null && annotations[i].length > 0) break;
}
if (i == levels) // empty annotations array ?
return type;
if (j
< 0) // Not kosher, broken type that is not flagged as invalid while reporting
// compilation error ? don't touch.
return type;
// types[j] is the first component being annotated. Its annotations are annotations[i]
for (enclosingType = j == 0 ? null : types[j - 1]; i < levels; i++, j++) {
final TypeBinding currentType = types[j];
// while handling annotations from SE7 locations, take care not to drop existing
// annotations.
AnnotationBinding[] currentAnnotations =
annotations[i] != null && annotations[i].length > 0
? annotations[i]
: currentType.getTypeAnnotations();
annotatedType = getAnnotatedType(currentType, enclosingType, currentAnnotations);
enclosingType = annotatedType;
}
break;
default:
throw new IllegalStateException();
}
return annotatedType;
}
