/** * Creates a wildcard reference to {@link Object} or returns a wildcard to an {@link UnknownTypeReference} if no * JRE is available. */ @Override public WildcardTypeReference newWildcardExtendsObject() { WildcardTypeReference result = newWildcardTypeReference(); result.addUpperBound(newReferenceToObject()); return result; }
/** * Creates a new wildcard type reference with the given type as the upper bound. * For example: * <pre>wildcardExtends(typeRef(CharSequence))</pre> * would create a type reference representing * <pre>? extends CharSequence</pre> * * @param extendsBound * the upper bound of the wildcard * @return the newly created wildcard type reference */ public JvmTypeReference wildcardExtends(JvmTypeReference extendsBound) { WildcardTypeReference wildcardTypeReference = typeReferenceOwner.newWildcardTypeReference(); wildcardTypeReference.addUpperBound(typeReferenceOwner.toLightweightTypeReference(extendsBound)); return wildcardTypeReference.toTypeReference(); }
/** * The map type may be constructed from different pairs, e.g. the pair's type arguments don't need to be as strict * as the map suggests. The pair's expectation is adjusted accordingly. */ protected LightweightTypeReference createNormalizedPairType(LightweightTypeReference pairType, LightweightTypeReference mapType, ITypeReferenceOwner owner) { ParameterizedTypeReference result = new ParameterizedTypeReference(owner, pairType.getType()); LightweightTypeReference keyType = mapType.getTypeArguments().get(0); if (keyType.getKind() != LightweightTypeReference.KIND_WILDCARD_TYPE_REFERENCE) { WildcardTypeReference wc = new WildcardTypeReference(owner); wc.addUpperBound(keyType); keyType = wc; } LightweightTypeReference valueType = mapType.getTypeArguments().get(1); if (valueType.getKind() != LightweightTypeReference.KIND_WILDCARD_TYPE_REFERENCE) { WildcardTypeReference wc = new WildcardTypeReference(owner); wc.addUpperBound(valueType); valueType = wc; } result.addTypeArgument(keyType); result.addTypeArgument(valueType); return result; }
@Override protected LightweightTypeReference enhanceParameterizedTypeReference(ParameterizedTypeReference reference, JvmType type, ParameterizedTypeReference result, ConstraintVisitingInfo visiting) { boolean convertToWildcard = false; for(int i = 0; i < reference.getTypeArguments().size(); i++) { wasCapturedWildcard = false; LightweightTypeReference argument = reference.getTypeArguments().get(i); visiting.pushInfo(type instanceof JvmTypeParameterDeclarator ? (JvmTypeParameterDeclarator) type : null, i); LightweightTypeReference visitedArgument = argument.accept(this, visiting); if (wasCapturedWildcard) convertToWildcard = true; wasCapturedWildcard = false; result.addTypeArgument(visitedArgument); } if (convertToWildcard) { WildcardTypeReference wildcard = result.getOwner().newWildcardTypeReference(); wildcard.addUpperBound(result); return wildcard; } return result; }
@Override protected LocalTypeSubstitutor.SubstitutionResult doVisitWildcardTypeReference(WildcardTypeReference reference, VarianceInfo varianceInfo) { WildcardTypeReference result = owner.newWildcardTypeReference(); LightweightTypeReference lowerBound = reference.getLowerBound(); boolean didSubstitute = false; if (lowerBound != null) { SubstitutionResult visited = lowerBound.accept(this, VarianceInfo.IN); result.setLowerBound(visited.typeReference); didSubstitute = didSubstitute || visited.didSubstitute; } for(LightweightTypeReference upperBound: reference.getUpperBounds()) { SubstitutionResult visited = upperBound.accept(this, VarianceInfo.OUT); result.addUpperBound(visited.typeReference); didSubstitute = didSubstitute || visited.didSubstitute; } if (result.getUpperBounds().isEmpty()) { throw new IllegalStateException("UpperBounds may not be empty"); } return new SubstitutionResult(result, didSubstitute); }
if (constraint instanceof JvmUpperBound) { upperBoundSeen = true; result.addUpperBound(visit(constraint.getTypeReference()).getWrapperTypeIfPrimitive()); } else if (result.getLowerBound() == null) { result.setLowerBound(visit(constraint.getTypeReference()).getWrapperTypeIfPrimitive()); if (!upperBoundSeen) { LightweightTypeReference upperBound = getObjectReference(); result.addUpperBound(upperBound); if (!upperBoundSeen && result.getLowerBound() != null) { LightweightTypeReference upperBound = getObjectReference(); result.addUpperBound(upperBound);
@Override /* @Nullable */ protected LightweightTypeReference getBoundTypeArgument(ParameterizedTypeReference reference, JvmTypeParameter type, Set<JvmTypeParameter> visiting) { LightweightMergedBoundTypeArgument boundTypeArgument = getTypeParameterMapping().get(type); if (boundTypeArgument != null && boundTypeArgument.getTypeReference() != reference) { LightweightTypeReference boundReference = boundTypeArgument.getTypeReference(); if (boundTypeArgument.getVariance() == VarianceInfo.OUT) { WildcardTypeReference wildcard = getOwner().newWildcardTypeReference(); wildcard.addUpperBound(boundReference); boundReference = wildcard; } return boundReference.accept(this, visiting); } return null; } };
protected LightweightTypeReference getDeclaredUpperBound(JvmTypeParameter typeParameter, ConstraintVisitingInfo visiting) { if (!typeParameter.getConstraints().isEmpty()) { JvmTypeConstraint constraint = typeParameter.getConstraints().get(0); if (constraint instanceof JvmUpperBound) { LightweightTypeReference reference = getOwner().toLightweightTypeReference(constraint.getTypeReference()); if (visiting.getCurrentDeclarator() != reference.getType()) { return visitTypeArgument(reference, visiting); } WildcardTypeReference result = getOwner().newWildcardTypeReference(); result.addUpperBound(getObjectReference()); return result; } } return null; }
/** * Creates a new wildcard type reference with the given type as the lower bound and {@link Object} as upper bound. * * For example: * <pre>wildcardSuper(typeRef(CharSequence))</pre> * would create a type reference representing * <pre>? super CharSequence</pre> * * @param superBound * the super bound of the wildcard * @return the newly created wildcard type reference */ public JvmTypeReference wildcardSuper(JvmTypeReference superBound) { WildcardTypeReference wildcardTypeReference = typeReferenceOwner.newWildcardTypeReference(); wildcardTypeReference.addUpperBound(typeReferenceOwner.toLightweightTypeReference(typeRef(Object.class))); wildcardTypeReference.setLowerBound(typeReferenceOwner.toLightweightTypeReference(superBound)); return wildcardTypeReference.toTypeReference(); }
case INVARIANT: WildcardTypeReference wc = owner.newWildcardTypeReference(); wc.addUpperBound(visited.typeReference); return new SubstitutionResult(wc, true); default: case INVARIANT: WildcardTypeReference wc = owner.newWildcardTypeReference(); wc.addUpperBound(result); return new SubstitutionResult(wc, true); default:
@Override protected LightweightTypeReference doVisitWildcardTypeReference(WildcardTypeReference reference, ConstraintVisitingInfo visiting) { if (reference.isResolved() && reference.isOwnedBy(getOwner())) return reference; LightweightTypeReference lowerBound = reference.getLowerBound(); if (lowerBound instanceof UnboundTypeReference) { if (!handles.add(((UnboundTypeReference) lowerBound).getHandle())) { WildcardTypeReference result = getOwner().newWildcardTypeReference(); for(LightweightTypeReference upperBound: reference.getUpperBounds()) { result.addUpperBound(visitTypeArgument(upperBound, visiting)); } return result; } } return super.doVisitWildcardTypeReference(reference, visiting); }
@Override protected WildcardTypeReference doCopyInto(ITypeReferenceOwner owner) { WildcardTypeReference result = owner.newWildcardTypeReference(); if (upperBounds != null && !upperBounds.isEmpty()) { for(LightweightTypeReference upperBound: upperBounds) { LightweightTypeReference copiedUpperBound = upperBound.copyInto(owner).getInvariantBoundSubstitute(); if (!(copiedUpperBound.isPrimitive() || copiedUpperBound.isPrimitiveVoid())) { result.addUpperBound(copiedUpperBound); } } } if (lowerBound != null) { LightweightTypeReference copiedLowerBound = lowerBound.copyInto(owner).getInvariantBoundSubstitute(); if (!(copiedLowerBound.isPrimitive() || copiedLowerBound.isPrimitiveVoid())) { result.setLowerBound(copiedLowerBound); } } return result; }
ParameterizedTypeReference result = owner.newParameterizedTypeReference(((JvmOperation) feature).getReturnType().getType()); WildcardTypeReference wildcard = owner.newWildcardTypeReference(); wildcard.addUpperBound(owner.toPlainTypeReference(rawTypes.get(0))); result.addTypeArgument(wildcard); return result;
case INVARIANT: WildcardTypeReference wc = owner.newWildcardTypeReference(); wc.addUpperBound(visited.typeReference); return new SubstitutionResult(wc, true); default: case INVARIANT: WildcardTypeReference wc = owner.newWildcardTypeReference(); wc.addUpperBound(result); return new SubstitutionResult(wc, true); default:
@Override /* @Nullable */ protected LightweightTypeReference getDeclaredUpperBound(JvmTypeParameter typeParameter, ConstraintVisitingInfo visiting) { if (!typeParameter.getConstraints().isEmpty() && ((DeclaredConstraintVisitingInfo)visiting).tryVisitDeclaredUpperBoundsOf(typeParameter)) { try { JvmTypeConstraint constraint = typeParameter.getConstraints().get(0); if (constraint instanceof JvmUpperBound) { LightweightTypeReference reference = getOwner().toLightweightTypeReference(constraint.getTypeReference()); if (visiting.getCurrentDeclarator() != reference.getType()) { return reference.accept(this, visiting); } WildcardTypeReference result = getOwner().newWildcardTypeReference(); result.addUpperBound(getObjectReference()); return result; } } finally { ((DeclaredConstraintVisitingInfo)visiting).didVisitDeclaredUpperBoundsOf(typeParameter); } } return null; }
LightweightTypeReference lowerBoundSubstitute = visited.getLowerBoundSubstitute(); if (lowerBoundSubstitute.isAny()) { result.addUpperBound(getOwner().newReferenceToObject()); return result; } else { LightweightTypeReference visitedArgument = visitTypeArgument(upperBound, visiting); LightweightTypeReference upperBoundSubstitute = visitedArgument.getUpperBoundSubstitute(); result.addUpperBound(upperBoundSubstitute);
ParameterizedTypeReference result = owner.newParameterizedTypeReference(((JvmOperation) feature).getReturnType().getType()); WildcardTypeReference wildcard = owner.newWildcardTypeReference(); wildcard.addUpperBound(owner.toPlainTypeReference(rawTypes.get(0))); result.addTypeArgument(wildcard); return result;
@Override protected LightweightTypeReference doVisitWildcardTypeReference(WildcardTypeReference reference, Set<JvmTypeParameter> visiting) { if (reference.isResolved() && reference.isOwnedBy(getOwner())) return reference; WildcardTypeReference result = getOwner().newWildcardTypeReference(); LightweightTypeReference lowerBound = reference.getLowerBound(); if (lowerBound != null) { LightweightTypeReference visited = visitTypeArgument(lowerBound, visiting, true); if (visited.isWildcard()) { LightweightTypeReference substitute = visited.getInvariantBoundSubstitute(); result.setLowerBound(substitute); } else { result.setLowerBound(visited); } } for(LightweightTypeReference upperBound: reference.getUpperBounds()) { LightweightTypeReference visitedArgument = visitTypeArgument(upperBound, visiting); LightweightTypeReference upperBoundSubstitute = visitedArgument.getUpperBoundSubstitute(); result.addUpperBound(upperBoundSubstitute); } if (result.getUpperBounds().isEmpty()) { throw new IllegalStateException("UpperBounds may not be empty"); } return result; } };
final WildcardTypeReference typeArgument = this.getOwner().newWildcardTypeReference(); typeArgument.setLowerBound(parameterType); typeArgument.addUpperBound(this.getJavaLangObjectTypeReference()); result.addTypeArgument(typeArgument); typeArgument.addUpperBound(returnType); result.addTypeArgument(typeArgument);
ParameterizedTypeReference reference = owner.newParameterizedTypeReference(iterableType); WildcardTypeReference wildcard = owner.newWildcardTypeReference(); wildcard.addUpperBound(addAsArrayComponentAndIterable); reference.addTypeArgument(wildcard); compoundResult.addComponent(reference);