@Override protected boolean shouldProcessInContextOf(JvmTypeParameter declaredTypeParameter, Set<JvmTypeParameter> boundParameters, Set<JvmTypeParameter> visited) { if (getOwner().getDeclaredTypeParameters().contains(declaredTypeParameter)) return true; if (boundParameters.contains(declaredTypeParameter) && !visited.add(declaredTypeParameter)) { return false; } return true; } }
protected boolean isBoundTypeArgumentSkipped(JvmTypeParameter type, Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> mapping, ITypeReferenceOwner owner) { return (type.getDeclarator() instanceof JvmType) && owner.getDeclaredTypeParameters().contains(type) && !mapping.containsKey(type); }
protected boolean isDeclaredTypeParameter(JvmTypeParameter typeParameter) { return getOwner().getDeclaredTypeParameters().contains(typeParameter); }
@Override /* @Nullable */ protected LightweightTypeReference getBoundTypeArgument(ParameterizedTypeReference reference, JvmTypeParameter type, ConstraintVisitingInfo visiting) { if (getOwner().getDeclaredTypeParameters().contains(type)) { return null; } return super.getBoundTypeArgument(reference, type, visiting); }
@Override protected void initializeMapping(JvmTypeParameter typeParameter, Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> result) { ITypeReferenceOwner owner = getState().getReferenceOwner(); if (typeParameter.getDeclarator() instanceof JvmType && owner.getDeclaredTypeParameters().contains(typeParameter)) { LightweightTypeReference typeReference = owner.newParameterizedTypeReference(typeParameter); result.put(typeParameter, new LightweightMergedBoundTypeArgument(typeReference, VarianceInfo.INVARIANT)); } else { super.initializeMapping(typeParameter, result); } }
@Override protected Boolean doVisitParameterizedTypeReference(ParameterizedTypeReference reference) { if (reference.isResolved()) { return true; } if (reference.getOwner().getDeclaredTypeParameters().contains(reference.getType())) { return true; } if (!visit(reference.getTypeArguments())) { return false; } return !(reference.getType() instanceof JvmTypeParameter); }
@Override protected LightweightTypeReference getUnmappedSubstitute(ParameterizedTypeReference reference, JvmTypeParameter type, ConstraintVisitingInfo visiting) { List<JvmTypeParameter> declaredTypeParameters = getOwner().getDeclaredTypeParameters(); if (declaredTypeParameters.contains(type)) { return reference.copyInto(getOwner()); } LightweightTypeReference result = createUnboundTypeReference(type); if (result == null) { result = new TypeParameterByConstraintSubstitutor(getTypeParameterMapping(), getOwner()).substitute(type); } return result; }
@Override public LightweightTypeReference doVisitParameterizedTypeReference(ParameterizedTypeReference reference) { DeclaratorTypeArgumentCollector typeArgumentCollector = new ConstraintAwareTypeArgumentCollector(owner); Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> typeParameterMapping = typeArgumentCollector.getTypeParameterMapping(reference); TypeParameterSubstitutor<?> substitutor = new UnboundTypeParameterPreservingSubstitutor(typeParameterMapping, owner); JvmGenericType iterable = (JvmGenericType) owner.getServices().getTypeReferences().findDeclaredType(Iterable.class, owner.getContextResourceSet()); if (iterable == null) { return owner.newReferenceToObject(); } LightweightTypeReference substituteMe = owner.newParameterizedTypeReference(iterable.getTypeParameters().get(0)); LightweightTypeReference substitutedArgument = substitutor.substitute(substituteMe).getUpperBoundSubstitute(); if (substitutedArgument.getType() instanceof JvmTypeParameter && !(owner.getDeclaredTypeParameters().contains(substitutedArgument.getType()))) { return substitutedArgument.getRawTypeReference(); } return substitutedArgument; }
if (getOwner().getDeclaredTypeParameters().contains(reference.getTypeParameter())) { reference.acceptHint(declaration, BoundTypeArgumentSource.RESOLVED, this, VarianceInfo.INVARIANT, VarianceInfo.INVARIANT); return;