@Override public UnresolvedType parameterize(Map<String, UnresolvedType> typeBindings) { if (this.kind == UNBOUND) { return this; } ReferenceType[] parameterizedAdditionalInterfaces = new ReferenceType[additionalInterfaceBounds == null ? 0 : additionalInterfaceBounds.length]; for (int i = 0; i < parameterizedAdditionalInterfaces.length; i++) { parameterizedAdditionalInterfaces[i] = (ReferenceType) additionalInterfaceBounds[i].parameterize(typeBindings); } if (this.kind == EXTENDS) { return new BoundedReferenceType((ReferenceType) getUpperBound().parameterize(typeBindings), true, world, parameterizedAdditionalInterfaces); } else { // (this.kind == SUPER) return new BoundedReferenceType((ReferenceType) getLowerBound().parameterize(typeBindings), false, world, parameterizedAdditionalInterfaces); } }
public boolean canBeCoercedTo(ResolvedType aCandidateType) { if (alwaysMatches(aCandidateType)) { return true; ResolvedType myUpperBound = (ResolvedType) getUpperBound(); ResolvedType myLowerBound = (ResolvedType) getLowerBound(); if (isExtends()) { if (boundedRT.isExtends()) { return myUpperBound.isAssignableFrom((ResolvedType) boundedRT.getUpperBound()); } else if (boundedRT.isSuper()) { return myUpperBound == boundedRT.getLowerBound(); } else { return true; // it's '?' } else if (isSuper()) { if (boundedRT.isSuper()) { return ((ResolvedType) boundedRT.getLowerBound()).isAssignableFrom(myLowerBound); } else if (boundedRT.isExtends()) { return myLowerBound == boundedRT.getUpperBound(); } else { return true;
/** * only for use when resolving GenericsWildcardTypeX or a TypeVariableReferenceType */ protected BoundedReferenceType(String signature, String erasedSignature, World world) { super(signature, erasedSignature, world); if (signature.equals("*")) { // pure wildcard this.kind = UNBOUND; upperBound = world.resolve(UnresolvedType.OBJECT); } else { upperBound = world.resolve(forSignature(erasedSignature)); } setDelegate(new BoundedReferenceTypeDelegate((ReferenceType) upperBound)); }
@Override public String getSimpleName() { if (!isExtends() && !isSuper()) { return "?"; } if (isExtends()) { return ("? extends " + getUpperBound().getSimpleName()); } else { return ("? super " + getLowerBound().getSimpleName()); } }
public BoundedReferenceType(ReferenceType aBound, boolean isExtends, World world) { super((isExtends ? "+" : "-") + aBound.signature, aBound.signatureErasure, world); if (isExtends) { this.kind = EXTENDS; } else { this.kind = SUPER; } if (isExtends) { upperBound = aBound; } else { lowerBound = aBound; upperBound = world.resolve(UnresolvedType.OBJECT); } setDelegate(new BoundedReferenceTypeDelegate((ReferenceType) getUpperBound())); }
if (upperBound == null && boundedRT.getUpperBound() != null) { if (!boundedRT.getUpperBound().getName().equals(UnresolvedType.OBJECT.getName())) { return false; if (lowerBound == null && boundedRT.getLowerBound() != null) { return false; if (aType.isGenericWildcard() && boundedRT.isSuper()) { return false; if (boundedRT.getUpperBound() == null) { return false; return upperBound.matches((ResolvedType) boundedRT.getUpperBound(), staticOrDynamic).alwaysTrue(); if (!(boundedRT.isGenericWildcard() && boundedRT.isSuper())) { return false; return lowerBound.matches((ResolvedType) boundedRT.getLowerBound(), staticOrDynamic).alwaysTrue();
} else { BoundedReferenceType boundedRT = (BoundedReferenceType) myParameters[i]; if (boundedRT.isExtends() || boundedRT.isSuper()) { wildcardsAllTheWay = false; } else { BoundedReferenceType wildcardType = (BoundedReferenceType) myParameters[i]; if (!wildcardType.alwaysMatches(theirParameters[i])) { parametersAssignable = false; break;
private BoundedReferenceType getWildcard() { if (wildcard == null) { wildcard = new BoundedReferenceType(this); } return wildcard; }
newTypeParams[i] = brType.parameterize(typeBindings);
BoundedReferenceType wildcard = (BoundedReferenceType) myTypeParameters[i]; if (!wildcard .canBeCoercedTo(theirTypeParameters[i])) { return false; if (!wildcard.canBeCoercedTo(myTypeParameters[i])) { return false;
/** * Go from an unresolved generic wildcard (represented by UnresolvedType) to a resolved version (BoundedReferenceType). */ private ReferenceType resolveGenericWildcardFor(WildcardedUnresolvedType aType) { BoundedReferenceType ret = null; // FIXME asc doesnt take account of additional interface bounds (e.g. ? super R & Serializable - can you do that?) if (aType.isExtends()) { ResolvedType resolvedUpperBound = resolve(aType.getUpperBound()); if (resolvedUpperBound.isMissing()) { return getWildcard(); } ret = new BoundedReferenceType((ReferenceType)resolvedUpperBound, true, this); } else if (aType.isSuper()) { ResolvedType resolvedLowerBound = resolve(aType.getLowerBound()); if (resolvedLowerBound.isMissing()) { return getWildcard(); } ret = new BoundedReferenceType((ReferenceType)resolvedLowerBound, false, this); } else { // must be ? on its own! ret = getWildcard(); } return ret; }
public boolean alwaysMatches(ResolvedType aCandidateType) { if (isExtends()) { // aCandidateType must be a subtype of upperBound return ((ReferenceType) getUpperBound()).isAssignableFrom(aCandidateType); } else if (isSuper()) { // aCandidateType must be a supertype of lowerBound return aCandidateType.isAssignableFrom((ReferenceType) getLowerBound()); } else { return true; // straight '?' } }
bound = fromType(lowerBounds[0]); return new BoundedReferenceType((ReferenceType) bound, isExtends, getWorld()); } else if (type instanceof GenericArrayType) { GenericArrayType genericArrayType = (GenericArrayType) type;
} else { ReferenceType upper = (ReferenceType) upperBound.getExactType().resolve(scope.getWorld()); type = new BoundedReferenceType(upper, true, scope.getWorld()); } else { ReferenceType lower = (ReferenceType) lowerBound.getExactType().resolve(scope.getWorld()); type = new BoundedReferenceType(lower, false, scope.getWorld());
if (boundedRT.isExtends()) { boolean b = false; UnresolvedType upperBound = boundedRT.getUpperBound(); if (upperBound.isParameterizedType()) { b = ((ResolvedType) upperBound).isParameterizedWithTypeVariable(); if (boundedRT.isSuper()) { boolean b = false; UnresolvedType lowerBound = boundedRT.getLowerBound(); if (lowerBound.isParameterizedType()) { b = ((ResolvedType) lowerBound).isParameterizedWithTypeVariable();
return new BoundedReferenceType(rBound, false, world); } else if (aTypeArgument.isPlus) { UnresolvedType bound = fieldTypeSignature2TypeX(aTypeArgument.signature, typeParams, world, return new BoundedReferenceType(rBound, true, world); } else { return fieldTypeSignature2TypeX(aTypeArgument.signature, typeParams, world, inProgressTypeVariableResolutions);