public TypeBinding checkResolvedType(
TypeBinding type, Scope scope, int location, boolean hasError) {
// SH}
if (type.isArrayType() && ((ArrayBinding) type).leafComponentType == TypeBinding.VOID) {
scope.problemReporter().cannotAllocateVoidArray(this);
return null;
}
if (!(this
instanceof
QualifiedTypeReference) // QualifiedTypeReference#getTypeBinding called above will have
// already checked deprecation
&& isTypeUseDeprecated(type, scope)) {
reportDeprecatedType(type, scope);
}
type =
scope
.environment()
.convertToRawType(type, false /*do not force conversion of enclosing types*/);
if (type.leafComponentType().isRawType()
&& (this.bits & ASTNode.IgnoreRawTypeCheck) == 0
&& scope.compilerOptions().getSeverity(CompilerOptions.RawTypeReference)
!= ProblemSeverities.Ignore) {
scope.problemReporter().rawTypeReference(this, type);
}
if (hasError) {
resolveAnnotations(scope, 0); // don't apply null defaults to buggy type
return type;
} else {
// store the computed type only if no error, otherwise keep the problem type instead
this.resolvedType = type;
resolveAnnotations(scope, location);
return this
.resolvedType; // pick up value that may have been changed in resolveAnnotations(..)
}
}
public String annotatedDebugName() {
StringBuffer buffer = new StringBuffer(10);
buffer.append(super.annotatedDebugName());
if (!this.inRecursiveFunction) {
this.inRecursiveFunction = true;
try {
if (this.superclass != null && TypeBinding.equalsEquals(this.firstBound, this.superclass)) {
buffer.append(" extends ").append(this.superclass.annotatedDebugName()); // $NON-NLS-1$
}
if (this.superInterfaces != null && this.superInterfaces != Binding.NO_SUPERINTERFACES) {
if (TypeBinding.notEquals(this.firstBound, this.superclass)) {
buffer.append(" extends "); // $NON-NLS-1$
}
for (int i = 0, length = this.superInterfaces.length; i < length; i++) {
if (i > 0 || TypeBinding.equalsEquals(this.firstBound, this.superclass)) {
buffer.append(" & "); // $NON-NLS-1$
}
buffer.append(this.superInterfaces[i].annotatedDebugName());
}
}
} finally {
this.inRecursiveFunction = false;
}
}
return buffer.toString();
}
/** Returns true if the type variable is directly bound to a given type */
public boolean isErasureBoundTo(TypeBinding type) {
if (TypeBinding.equalsEquals(this.superclass.erasure(), type)) return true;
for (int i = 0, length = this.superInterfaces.length; i < length; i++) {
if (TypeBinding.equalsEquals(this.superInterfaces[i].erasure(), type)) return true;
}
return false;
}
public void resolveReceiver() {
if (this.receiver == null) return;
if (this.receiver.modifiers != 0) {
this.scope
.problemReporter()
.illegalModifiers(
this.receiver.declarationSourceStart, this.receiver.declarationSourceEnd);
}
TypeBinding resolvedReceiverType = this.receiver.type.resolvedType;
if (this.binding == null
|| resolvedReceiverType == null
|| !resolvedReceiverType.isValidBinding()) {
return;
}
ReferenceBinding declaringClass = this.binding.declaringClass;
/* neither static methods nor methods in anonymous types can have explicit 'this' */
if (this.isStatic() || declaringClass.isAnonymousType()) {
this.scope.problemReporter().disallowedThisParameter(this.receiver);
return; // No need to do further validation
}
ReferenceBinding enclosingReceiver = this.scope.enclosingReceiverType();
if (this.isConstructor()) {
/* Only non static member types or local types can declare explicit 'this' params in constructors */
if (declaringClass.isStatic()
|| (declaringClass.tagBits & (TagBits.IsLocalType | TagBits.IsMemberType)) == 0) {
/* neither member nor local type */
this.scope.problemReporter().disallowedThisParameter(this.receiver);
return; // No need to do further validation
}
enclosingReceiver = enclosingReceiver.enclosingType();
}
char[][] tokens =
(this.receiver.qualifyingName == null) ? null : this.receiver.qualifyingName.getName();
if (this.isConstructor()) {
if (tokens == null
|| tokens.length > 1
|| !CharOperation.equals(enclosingReceiver.sourceName(), tokens[0])) {
this.scope
.problemReporter()
.illegalQualifierForExplicitThis(this.receiver, enclosingReceiver);
this.receiver.qualifyingName = null;
}
} else if (tokens != null && tokens.length > 0) {
this.scope.problemReporter().illegalQualifierForExplicitThis2(this.receiver);
this.receiver.qualifyingName = null;
}
if (TypeBinding.notEquals(enclosingReceiver, resolvedReceiverType)) {
this.scope.problemReporter().illegalTypeForExplicitThis(this.receiver, enclosingReceiver);
}
if (this.receiver.type.hasNullTypeAnnotation(AnnotationPosition.ANY)) {
this.scope.problemReporter().nullAnnotationUnsupportedLocation(this.receiver.type);
}
}
public String process() {
if (this.type.getCanonicalName() == null) {
new RuntimeException("" + this.type).printStackTrace();
} else {
this.elem(Elem.mapping);
if (this.abs) {
this.attr("abstract", "true");
} else {
this.attr("name", this.type.getSimpleName())
.attr("extends", this.type.getSuperclass().getCanonicalName());
}
this.attr("class", this.type.getCanonicalName());
if (BindingGenerator.MSG_TYPE.isAssignableFrom(this.type.getSuperclass())
|| BindingGenerator.DATA_TYPE.isAssignableFrom(this.type.getSuperclass())) {
this.elem(Elem.structure)
.attr("map-as", this.type.getSuperclass().getCanonicalName())
.end();
}
for (Field f : type.getDeclaredFields()) {
TypeBinding tb = getTypeBinding(f);
if (!(tb instanceof NoopTypeBinding)) {
System.out.printf(
"BOUND: %-70s [type=%s:%s]\n",
f.getDeclaringClass().getCanonicalName() + "." + f.getName(),
tb.getTypeName(),
f.getType().getCanonicalName());
this.append(tb.toString());
}
}
this.end();
}
return this.toString();
}
/** @see TypeBinding#isEquivalentTo(TypeBinding) */
public boolean isEquivalentTo(TypeBinding otherType) {
// from CaptureBinding:
if (equalsEquals(this, otherType)) return true;
if (otherType == null) return false;
if (this.upperBounds != null) {
// from CaptureBinding:
for (int i = 0; i < this.upperBounds.length; i++) {
TypeBinding aBound = this.upperBounds[i];
// capture of ? extends X[]
if (aBound != null && aBound.isArrayType()) {
if (!aBound.isCompatibleWith(otherType)) continue;
}
switch (otherType.kind()) {
case Binding.WILDCARD_TYPE:
case Binding.INTERSECTION_TYPE:
if (!((WildcardBinding) otherType).boundCheck(aBound)) return false;
break;
default:
return false;
}
}
return true;
}
return false;
}
/**
* Collect the substitutes into a map for certain type variables inside the receiver type e.g.
* Collection<T>.collectSubstitutes(Collection<List<X>>, Map), will populate Map with: T -->
* List<X> Constraints: A << F corresponds to: F.collectSubstitutes(..., A, ...,
* CONSTRAINT_EXTENDS (1)) A = F corresponds to: F.collectSubstitutes(..., A, ...,
* CONSTRAINT_EQUAL (0)) A >> F corresponds to: F.collectSubstitutes(..., A, ..., CONSTRAINT_SUPER
* (2))
*/
public void collectSubstitutes(
Scope scope, TypeBinding actualType, InferenceContext inferenceContext, int constraint) {
if ((this.tagBits & TagBits.HasTypeVariable) == 0) return;
if (actualType == TypeBinding.NULL) return;
switch (actualType.kind()) {
case Binding.ARRAY_TYPE:
int actualDim = actualType.dimensions();
if (actualDim == this.dimensions) {
this.leafComponentType.collectSubstitutes(
scope, actualType.leafComponentType(), inferenceContext, constraint);
} else if (actualDim > this.dimensions) {
ArrayBinding actualReducedType =
this.environment.createArrayType(
actualType.leafComponentType(), actualDim - this.dimensions);
this.leafComponentType.collectSubstitutes(
scope, actualReducedType, inferenceContext, constraint);
}
break;
case Binding.TYPE_PARAMETER:
// TypeVariableBinding variable = (TypeVariableBinding) otherType;
// TODO (philippe) should consider array bounds, and recurse
break;
}
}
public String process() {
if (this.type.getCanonicalName() == null) {
// new RuntimeException( "Ignoring anonymous class: " + this.type
// ).printStackTrace( );
} else {
this.elem(Elem.mapping);
if (this.abs) {
this.attr("abstract", "true");
} else {
this.attr("name", this.type.getSimpleName())
.attr("extends", this.type.getSuperclass().getCanonicalName());
}
this.attr("class", this.type.getCanonicalName());
if (BindingFileSearch.INSTANCE.MSG_BASE_CLASS.isAssignableFrom(this.type.getSuperclass())
|| BindingFileSearch.INSTANCE.MSG_DATA_CLASS.isAssignableFrom(
this.type.getSuperclass())) {
this.elem(Elem.structure)
.attr("map-as", this.type.getSuperclass().getCanonicalName())
.end();
}
for (Field f : this.type.getDeclaredFields()) {
if (!Ats.from(f).has(Transient.class) || Modifier.isTransient(f.getModifiers())) {
TypeBinding tb = getTypeBinding(f);
if (!(tb instanceof NoopTypeBinding)) {
// System.out.printf( "BOUND: %-70s [type=%s:%s]\n",
// f.getDeclaringClass( ).getCanonicalName( ) +"."+ f.getName( ), tb.getTypeName( ),
// f.getType( ).getCanonicalName( ) );
this.append(tb.toString());
}
}
}
this.end();
}
return this.toString();
}
protected int findNullTypeAnnotationMismatch(TypeBinding requiredType, TypeBinding providedType) {
int severity = 0;
if (requiredType instanceof ArrayBinding) {
long[] requiredDimsTagBits = ((ArrayBinding) requiredType).nullTagBitsPerDimension;
if (requiredDimsTagBits != null) {
int dims = requiredType.dimensions();
if (requiredType.dimensions() == providedType.dimensions()) {
long[] providedDimsTagBits = ((ArrayBinding) providedType).nullTagBitsPerDimension;
if (providedDimsTagBits == null) {
severity = 1; // required is annotated, provided not, need unchecked conversion
} else {
for (int i = 0; i < dims; i++) {
long requiredBits = requiredDimsTagBits[i] & TagBits.AnnotationNullMASK;
long providedBits = providedDimsTagBits[i] & TagBits.AnnotationNullMASK;
if (requiredBits != 0 && requiredBits != providedBits) {
if (providedBits == 0)
severity = 1; // need unchecked conversion regarding type detail
else return 2; // mismatching annotations
}
}
}
}
}
}
return severity;
}
public boolean equalsEquals(ConstraintTypeFormula that) {
return (that != null
&& this.relation == that.relation
&& this.isSoft == that.isSoft
&& TypeBinding.equalsEquals(this.left, that.left)
&& TypeBinding.equalsEquals(this.right, that.right));
}
@Override
public char[] nullAnnotatedReadableName(CompilerOptions options, boolean shortNames) {
StringBuffer nameBuffer = new StringBuffer(10);
appendNullAnnotation(nameBuffer, options);
nameBuffer.append(this.sourceName());
if (!this.inRecursiveFunction) {
this.inRecursiveFunction = true;
try {
if (this.superclass != null && TypeBinding.equalsEquals(this.firstBound, this.superclass)) {
nameBuffer
.append(" extends ")
.append(
this.superclass.nullAnnotatedReadableName(options, shortNames)); // $NON-NLS-1$
}
if (this.superInterfaces != null && this.superInterfaces != Binding.NO_SUPERINTERFACES) {
if (TypeBinding.notEquals(this.firstBound, this.superclass)) {
nameBuffer.append(" extends "); // $NON-NLS-1$
}
for (int i = 0, length = this.superInterfaces.length; i < length; i++) {
if (i > 0 || TypeBinding.equalsEquals(this.firstBound, this.superclass)) {
nameBuffer.append(" & "); // $NON-NLS-1$
}
nameBuffer.append(
this.superInterfaces[i].nullAnnotatedReadableName(options, shortNames));
}
}
} finally {
this.inRecursiveFunction = false;
}
}
int nameLength = nameBuffer.length();
char[] readableName = new char[nameLength];
nameBuffer.getChars(0, nameLength, readableName, 0);
return readableName;
}
boolean denotesRelevantSuperClass(TypeBinding type) {
if (!type.isTypeVariable() && !type.isInterface() && type.id != TypeIds.T_JavaLangObject)
return true;
ReferenceBinding aSuperClass = type.superclass();
return aSuperClass != null
&& aSuperClass.id != TypeIds.T_JavaLangObject
&& !aSuperClass.isTypeVariable();
}
private Object reduceTypeEquality(TypeBinding object) {
// 18.2.4
if (this.left.kind() == Binding.WILDCARD_TYPE) {
if (this.right.kind() == Binding.WILDCARD_TYPE) {
// left and right are wildcards ("type arguments")
WildcardBinding leftWC = (WildcardBinding) this.left;
WildcardBinding rightWC = (WildcardBinding) this.right;
if (leftWC.boundKind == Wildcard.UNBOUND && rightWC.boundKind == Wildcard.UNBOUND)
return TRUE;
if (leftWC.boundKind == Wildcard.UNBOUND && rightWC.boundKind == Wildcard.EXTENDS)
return ConstraintTypeFormula.create(object, rightWC.bound, SAME, this.isSoft);
if (leftWC.boundKind == Wildcard.EXTENDS && rightWC.boundKind == Wildcard.UNBOUND)
return ConstraintTypeFormula.create(leftWC.bound, object, SAME, this.isSoft);
if ((leftWC.boundKind == Wildcard.EXTENDS && rightWC.boundKind == Wildcard.EXTENDS)
|| (leftWC.boundKind == Wildcard.SUPER && rightWC.boundKind == Wildcard.SUPER)) {
return ConstraintTypeFormula.create(leftWC.bound, rightWC.bound, SAME, this.isSoft);
}
}
} else {
if (this.right.kind() != Binding.WILDCARD_TYPE) {
// left and right are types (vs. wildcards)
if (this.left.isProperType(true) && this.right.isProperType(true)) {
if (TypeBinding.equalsEquals(this.left, this.right)) return TRUE;
return FALSE;
}
if (this.left instanceof InferenceVariable) {
return new TypeBound((InferenceVariable) this.left, this.right, SAME, this.isSoft);
}
if (this.right instanceof InferenceVariable) {
return new TypeBound((InferenceVariable) this.right, this.left, SAME, this.isSoft);
}
if ((this.left.isClass() || this.left.isInterface())
&& (this.right.isClass() || this.right.isInterface())
&& TypeBinding.equalsEquals(this.left.erasure(), this.right.erasure())) {
TypeBinding[] leftParams = this.left.typeArguments();
TypeBinding[] rightParams = this.right.typeArguments();
if (leftParams == null || rightParams == null)
return leftParams == rightParams ? TRUE : FALSE;
if (leftParams.length != rightParams.length) return FALSE;
int len = leftParams.length;
ConstraintFormula[] constraints = new ConstraintFormula[len];
for (int i = 0; i < len; i++) {
constraints[i] =
ConstraintTypeFormula.create(leftParams[i], rightParams[i], SAME, this.isSoft);
}
return constraints;
}
if (this.left.isArrayType()
&& this.right.isArrayType()
&& this.left.dimensions() == this.right.dimensions()) {
// checking dimensions already now is an optimization over reducing one dim at a time
return ConstraintTypeFormula.create(
this.left.leafComponentType(), this.right.leafComponentType(), SAME, this.isSoft);
}
}
}
return FALSE;
}
ReferenceBinding resolve() {
if ((this.modifiers & ExtraCompilerModifiers.AccUnresolved) == 0) return this;
long nullTagBits = this.tagBits & TagBits.AnnotationNullMASK;
TypeBinding oldSuperclass = this.superclass, oldFirstInterface = null;
if (this.superclass != null) {
ReferenceBinding resolveType =
(ReferenceBinding)
BinaryTypeBinding.resolveType(
this.superclass, this.environment, true /* raw conversion */);
this.tagBits |= resolveType.tagBits & TagBits.ContainsNestedTypeReferences;
long superNullTagBits = resolveType.tagBits & TagBits.AnnotationNullMASK;
if (superNullTagBits != 0L) {
if (nullTagBits == 0L) {
this.tagBits |= (superNullTagBits | TagBits.HasNullTypeAnnotation);
} else {
// System.err.println("TODO(stephan): report proper error: conflict binary
// TypeVariable vs. first bound");
}
}
this.setSuperClass(resolveType);
}
ReferenceBinding[] interfaces = this.superInterfaces;
int length;
if ((length = interfaces.length) != 0) {
oldFirstInterface = interfaces[0];
for (int i = length; --i >= 0; ) {
ReferenceBinding resolveType =
(ReferenceBinding)
BinaryTypeBinding.resolveType(
interfaces[i], this.environment, true /* raw conversion */);
this.tagBits |= resolveType.tagBits & TagBits.ContainsNestedTypeReferences;
long superNullTagBits = resolveType.tagBits & TagBits.AnnotationNullMASK;
if (superNullTagBits != 0L) {
if (nullTagBits == 0L) {
this.tagBits |= (superNullTagBits | TagBits.HasNullTypeAnnotation);
} else {
// System.err.println("TODO(stephan): report proper error: conflict binary
// TypeVariable vs. bound "+i);
}
}
interfaces[i] = resolveType;
}
}
// refresh the firstBound in case it changed
if (this.firstBound != null) {
if (TypeBinding.equalsEquals(this.firstBound, oldSuperclass)) {
this.setFirstBound(this.superclass);
} else if (TypeBinding.equalsEquals(this.firstBound, oldFirstInterface)) {
this.setFirstBound(interfaces[0]);
}
}
this.modifiers &= ~ExtraCompilerModifiers.AccUnresolved;
return this;
}
TypeBinding substituteInferenceVariable(InferenceVariable var, TypeBinding substituteType) {
if (this.inRecursiveFunction) return this;
this.inRecursiveFunction = true;
try {
boolean haveSubstitution = false;
ReferenceBinding currentSuperclass = this.superclass;
if (currentSuperclass != null) {
currentSuperclass =
(ReferenceBinding) currentSuperclass.substituteInferenceVariable(var, substituteType);
haveSubstitution |= TypeBinding.notEquals(currentSuperclass, this.superclass);
}
ReferenceBinding[] currentSuperInterfaces = null;
if (this.superInterfaces != null) {
int length = this.superInterfaces.length;
if (haveSubstitution)
System.arraycopy(
this.superInterfaces,
0,
currentSuperInterfaces = new ReferenceBinding[length],
0,
length);
for (int i = 0; i < length; i++) {
ReferenceBinding currentSuperInterface = this.superInterfaces[i];
if (currentSuperInterface != null) {
currentSuperInterface =
(ReferenceBinding)
currentSuperInterface.substituteInferenceVariable(var, substituteType);
if (TypeBinding.notEquals(currentSuperInterface, this.superInterfaces[i])) {
if (currentSuperInterfaces == null)
System.arraycopy(
this.superInterfaces,
0,
currentSuperInterfaces = new ReferenceBinding[length],
0,
length);
currentSuperInterfaces[i] = currentSuperInterface;
haveSubstitution = true;
}
}
}
}
if (haveSubstitution) {
TypeVariableBinding newVar =
new TypeVariableBinding(
this.sourceName, this.declaringElement, this.rank, this.environment);
newVar.superclass = currentSuperclass;
newVar.superInterfaces = currentSuperInterfaces;
newVar.tagBits = this.tagBits;
return newVar;
}
return this;
} finally {
this.inRecursiveFunction = false;
}
}
private TypeReference findBound(TypeBinding bound, TypeParameter parameter) {
if (parameter.type != null && TypeBinding.equalsEquals(parameter.type.resolvedType, bound))
return parameter.type;
TypeReference[] bounds = parameter.bounds;
if (bounds != null) {
for (int i = 0; i < bounds.length; i++) {
if (TypeBinding.equalsEquals(bounds[i].resolvedType, bound)) return bounds[i];
}
}
return null;
}
private boolean haveTypeAnnotations(
TypeBinding baseType,
TypeBinding someType,
TypeBinding[] someTypes,
AnnotationBinding[] annotations) {
if (baseType != null && baseType.hasTypeAnnotations()) return true;
if (someType != null && someType.hasTypeAnnotations()) return true;
for (int i = 0, length = annotations == null ? 0 : annotations.length; i < length; i++)
if (annotations[i] != null) return true;
for (int i = 0, length = someTypes == null ? 0 : someTypes.length; i < length; i++)
if (someTypes[i].hasTypeAnnotations()) return true;
return false;
}
/**
* Check whether this type reference conforms to the null constraints defined for the
* corresponding type variable.
*/
protected void checkNullConstraints(
Scope scope, Substitution substitution, TypeBinding[] variables, int rank) {
if (variables != null && variables.length > rank) {
TypeBinding variable = variables[rank];
if (variable.hasNullTypeAnnotations()) {
if (NullAnnotationMatching.analyse(
variable, this.resolvedType, null, substitution, -1, null, CheckMode.BOUND_CHECK)
.isAnyMismatch())
scope.problemReporter().nullityMismatchTypeArgument(variable, this.resolvedType, this);
}
}
checkIllegalNullAnnotation(scope);
}
public TypeBinding resolveType(BlockScope scope) {
this.constant = Constant.NotAConstant;
TypeBinding expressionType = this.expression.resolveType(scope);
TypeBinding checkedType = this.type.resolveType(scope, true /* check bounds*/);
if (expressionType == null || checkedType == null) return null;
if (!checkedType.isReifiable()) {
scope.problemReporter().illegalInstanceOfGenericType(checkedType, this);
} else if ((expressionType != TypeBinding.NULL
&& expressionType.isBaseType()) // disallow autoboxing
|| !checkCastTypesCompatibility(scope, checkedType, expressionType, null)) {
scope.problemReporter().notCompatibleTypesError(this, expressionType, checkedType);
}
return this.resolvedType = TypeBinding.BOOLEAN;
}
@Override
public long updateTagBits() {
if (!this.inRecursiveFunction) {
this.inRecursiveFunction = true;
try {
if (this.superclass != null) this.tagBits |= this.superclass.updateTagBits();
if (this.superInterfaces != null)
for (TypeBinding superIfc : this.superInterfaces)
this.tagBits |= superIfc.updateTagBits();
} finally {
this.inRecursiveFunction = false;
}
}
return super.updateTagBits();
}
public TypeBinding getTypeBinding(Field field) {
Class itsType = field.getType();
if (this.isIgnored(field)) {
return new NoopTypeBinding(field);
} else if (List.class.isAssignableFrom(itsType)) {
Class listType = getTypeArgument(field);
if (listType == null) {
Logs.extreme()
.debug(
String.format(
"IGNORE: %-70s [type=%s] NO GENERIC TYPE FOR LIST\n",
field.getDeclaringClass().getCanonicalName() + "." + field.getName(),
listType));
return new NoopTypeBinding(field);
} else if (this.typeBindings.containsKey(listType.getCanonicalName())) {
return new CollectionTypeBinding(
field.getName(), this.typeBindings.get(listType.getCanonicalName()));
} else if (BindingFileSearch.INSTANCE.MSG_DATA_CLASS.isAssignableFrom(listType)) {
return new CollectionTypeBinding(
field.getName(), new ObjectTypeBinding(field.getName(), listType));
} else {
Logs.extreme()
.debug(
String.format(
"IGNORE: %-70s [type=%s] LIST'S GENERIC TYPE DOES NOT CONFORM TO EucalyptusData\n",
field.getDeclaringClass().getCanonicalName() + "." + field.getName(),
listType.getCanonicalName()));
return new NoopTypeBinding(field);
}
} else if (this.typeBindings.containsKey(itsType.getCanonicalName())) {
TypeBinding t = this.typeBindings.get(itsType.getCanonicalName());
try {
t = this.typeBindings.get(itsType.getCanonicalName()).getClass().newInstance();
} catch (Exception e) {
}
return t.value(field.getName());
} else if (BindingFileSearch.INSTANCE.MSG_DATA_CLASS.isAssignableFrom(field.getType())) {
return new ObjectTypeBinding(field);
} else {
Logs.extreme()
.debug(
String.format(
"IGNORE: %-70s [type=%s] TYPE DOES NOT CONFORM TO EucalyptusData\n",
field.getDeclaringClass().getCanonicalName() + "." + field.getName(),
field.getType().getCanonicalName()));
return new NoopTypeBinding(field);
}
}
/**
* Collect the substitutes into a map for certain type variables inside the receiver type e.g.
* Collection<T>.collectSubstitutes(Collection<List<X>>, Map), will populate Map with: T -->
* List<X> Constraints: A << F corresponds to: F.collectSubstitutes(..., A, ...,
* CONSTRAINT_EXTENDS (1)) A = F corresponds to: F.collectSubstitutes(..., A, ...,
* CONSTRAINT_EQUAL (0)) A >> F corresponds to: F.collectSubstitutes(..., A, ..., CONSTRAINT_SUPER
* (2))
*/
public void collectSubstitutes(
Scope scope, TypeBinding actualType, InferenceContext inferenceContext, int constraint) {
// only infer for type params of the generic method
if (this.declaringElement != inferenceContext.genericMethod) return;
// cannot infer anything from a null type
switch (actualType.kind()) {
case Binding.BASE_TYPE:
if (actualType == TypeBinding.NULL) return;
TypeBinding boxedType = scope.environment().computeBoxingType(actualType);
if (boxedType == actualType) return; // $IDENTITY-COMPARISON$
actualType = boxedType;
break;
case Binding.POLY_TYPE: // cannot steer inference, only learn from it.
case Binding.WILDCARD_TYPE:
return; // wildcards are not true type expressions (JLS 15.12.2.7, p.453 2nd discussion)
}
// reverse constraint, to reflect variable on rhs: A << T --> T >: A
int variableConstraint;
switch (constraint) {
case TypeConstants.CONSTRAINT_EQUAL:
variableConstraint = TypeConstants.CONSTRAINT_EQUAL;
break;
case TypeConstants.CONSTRAINT_EXTENDS:
variableConstraint = TypeConstants.CONSTRAINT_SUPER;
break;
default:
// case CONSTRAINT_SUPER :
variableConstraint = TypeConstants.CONSTRAINT_EXTENDS;
break;
}
inferenceContext.recordSubstitute(this, actualType, variableConstraint);
}
/**
* Answer the receiver's constant pool name. NOTE: This method should only be used during/after
* code gen. e.g. '[Ljava/lang/Object;'
*/
public char[] constantPoolName() {
if (constantPoolName != null) return constantPoolName;
char[] brackets = new char[dimensions];
for (int i = dimensions - 1; i >= 0; i--) brackets[i] = '[';
return constantPoolName = CharOperation.concat(brackets, leafComponentType.signature());
}
protected boolean isBoxingCompatible(
TypeBinding expressionType, TypeBinding targetType, Expression expression, Scope scope) {
if (scope.isBoxingCompatibleWith(expressionType, targetType)) return true;
return expressionType
.isBaseType() // narrowing then boxing ? Only allowed for some target types see 362279
&& !targetType.isBaseType()
&& !targetType.isTypeVariable()
&& scope.compilerOptions().sourceLevel
>= org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants.JDK1_5 // autoboxing
&& (targetType.id == TypeIds.T_JavaLangByte
|| targetType.id == TypeIds.T_JavaLangShort
|| targetType.id == TypeIds.T_JavaLangCharacter)
&& expression.isConstantValueOfTypeAssignableToType(
expressionType, scope.environment().computeBoxingType(targetType));
}
void checkAssignment(BlockScope scope, TypeBinding lhsType, TypeBinding rhsType) {
FieldBinding leftField = getLastField(this.lhs);
if (leftField != null
&& rhsType != TypeBinding.NULL
&& (lhsType.kind() == Binding.WILDCARD_TYPE)
&& ((WildcardBinding) lhsType).boundKind != Wildcard.SUPER) {
scope.problemReporter().wildcardAssignment(lhsType, rhsType, this.expression);
} else if (leftField != null
&& !leftField.isStatic()
&& leftField.declaringClass != null /*length pseudo field*/
&& leftField.declaringClass.isRawType()) {
scope.problemReporter().unsafeRawFieldAssignment(leftField, rhsType, this.lhs);
} else if (rhsType.needsUncheckedConversion(lhsType)) {
scope.problemReporter().unsafeTypeConversion(this.expression, rhsType, lhsType);
}
}
public char[] readableName() /* java.lang.Object[] */ {
char[] brackets = new char[dimensions * 2];
for (int i = dimensions * 2 - 1; i >= 0; i -= 2) {
brackets[i] = ']';
brackets[i - 1] = '[';
}
return CharOperation.concat(leafComponentType.readableName(), brackets);
}
public char[] sourceName() {
char[] brackets = new char[dimensions * 2];
for (int i = dimensions * 2 - 1; i >= 0; i -= 2) {
brackets[i] = ']';
brackets[i - 1] = '[';
}
return CharOperation.concat(leafComponentType.sourceName(), brackets);
}
/* (non-Javadoc)
* @see org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding#superclass()
*/
public ReferenceBinding superclass() {
if (this.superclass == null) {
TypeBinding superType = null;
if (this.boundKind == Wildcard.EXTENDS && !this.bound.isInterface()) {
superType = this.bound;
} else {
TypeVariableBinding variable = typeVariable();
if (variable != null) superType = variable.firstBound;
}
this.superclass =
superType instanceof ReferenceBinding && !superType.isInterface()
? (ReferenceBinding) superType
: this.environment.getResolvedType(TypeConstants.JAVA_LANG_OBJECT, null);
}
return this.superclass;
}
/**
* Returns true if the 2 variables are playing exact same role: they have the same bounds,
* providing one is substituted with the other: <T1 extends List<T1>> is interchangeable with <T2
* extends List<T2>>.
*/
public boolean isInterchangeableWith(TypeVariableBinding otherVariable, Substitution substitute) {
if (TypeBinding.equalsEquals(this, otherVariable)) return true;
int length = this.superInterfaces.length;
if (length != otherVariable.superInterfaces.length) return false;
if (TypeBinding.notEquals(
this.superclass, Scope.substitute(substitute, otherVariable.superclass))) return false;
next:
for (int i = 0; i < length; i++) {
TypeBinding superType = Scope.substitute(substitute, otherVariable.superInterfaces[i]);
for (int j = 0; j < length; j++)
if (TypeBinding.equalsEquals(superType, this.superInterfaces[j])) continue next;
return false; // not a match
}
return true;
}
/*
* parameterizedDeclaringUniqueKey dot selector originalMethodGenericSignature percent typeArguments
* p.X<U> { <T> void bar(T t, U u) { new X<String>().bar(this, "") } } --> Lp/X<Ljava/lang/String;>;.bar<T:Ljava/lang/Object;>(TT;Ljava/lang/String;)V%<Lp/X;>
*/
public char[] computeUniqueKey(boolean isLeaf) {
StringBuffer buffer = new StringBuffer();
buffer.append(this.originalMethod.computeUniqueKey(false /*not a leaf*/));
buffer.append('%');
buffer.append('<');
if (!this.isRaw) {
int length = this.typeArguments.length;
for (int i = 0; i < length; i++) {
TypeBinding typeArgument = this.typeArguments[i];
buffer.append(typeArgument.computeUniqueKey(false /*not a leaf*/));
}
}
buffer.append('>');
int resultLength = buffer.length();
char[] result = new char[resultLength];
buffer.getChars(0, resultLength, result, 0);
return result;
}
