@Override protected List<LightweightTypeReference> getSuperTypes(TypeParameterSubstitutor<?> substitutor) { if (!isSynonym()) { if (components == null || components.isEmpty()) return Collections.emptyList(); List<LightweightTypeReference> result = Lists.newArrayListWithCapacity(components.size()); for(LightweightTypeReference component: components) { result.add(substitutor.substitute(component)); } return result; } return Collections.emptyList(); }
@Override protected void doVisitCompoundTypeReference(CompoundTypeReference reference, StringBuilder param) { String delimiter; if (reference.isSynonym()) { delimiter = " | "; } else { delimiter = " & "; } List<LightweightTypeReference> components = reference.getMultiTypeComponents(); for(int i = 0; i < components.size(); i++) { if (i != 0) { param.append(delimiter); } components.get(i).accept(this, param); } }
@Override protected void doVisitCompoundTypeReference(CompoundTypeReference reference, WildcardTypeReference param) { if (!reference.isSynonym()) { doVisitTypeReference(reference, param); } else { super.doVisitCompoundTypeReference(reference, param); } }
@Override protected void doVisitUnboundTypeReference(UnboundTypeReference reference, CompoundTypeReference declaration) { if (declaration.isSynonym()) { super.doVisitUnboundTypeReference(reference, declaration); } else { addHint(reference, declaration); } } };
@Override /* @Nullable */ public <Param, Result> Result accept(TypeReferenceVisitorWithParameterAndResult<Param, Result> visitor, Param param) { if (isSynonym()) return visitor.doVisitSynonymTypeReference(this, param); else return visitor.doVisitMultiTypeReference(this, param); }
@Override public void accept(TypeReferenceVisitor visitor) { if (isSynonym()) visitor.doVisitSynonymTypeReference(this); else visitor.doVisitMultiTypeReference(this); }
@Override /* @Nullable */ public <Result> Result accept(TypeReferenceVisitorWithResult<Result> visitor) { if (isSynonym()) return visitor.doVisitSynonymTypeReference(this); else return visitor.doVisitMultiTypeReference(this); }
@Override public <Param> void accept(TypeReferenceVisitorWithParameter<Param> visitor, Param param) { if (isSynonym()) visitor.doVisitSynonymTypeReference(this, param); else visitor.doVisitMultiTypeReference(this, param); }
@Override public boolean isType(Class<?> clazz) { if (components == null) return false; if (isSynonym()) { for(LightweightTypeReference component: components) { if (component.isType(clazz)) return true; } return false; } else { for(LightweightTypeReference component: components) { if (!component.isType(clazz)) return false; } return true; } }
/** * {@inheritDoc} * * If this is a multi-type rather than a {@link #isSynonym() synonym}, the Java compliant * type reference is determined from the common super type of all participating, non-interface types. * If there is no such type or this is a synonym, all the component types are used to compute * the common super type and use that one as the type. */ @Override public JvmTypeReference toJavaCompliantTypeReference(IVisibilityHelper visibilityHelper) { if (!isSynonym()) { List<LightweightTypeReference> nonInterfaceTypes = getNonInterfaceTypes(components); if (nonInterfaceTypes != null) { return toJavaCompliantTypeReference(nonInterfaceTypes, visibilityHelper); } } return toJavaCompliantTypeReference(components, visibilityHelper); }
@Override protected LightweightTypeReference doVisitCompoundTypeReference(CompoundTypeReference reference, ResourceSet resourceSet) { if (reference.isRawType()) return reference; CompoundTypeReference result = reference.getOwner().newCompoundTypeReference(reference.isSynonym()); enhanceCompoundReference(reference.getMultiTypeComponents(), result, resourceSet); return result; }
@Override protected LocalTypeSubstitutor.SubstitutionResult doVisitCompoundTypeReference(CompoundTypeReference reference, VarianceInfo varianceInfo) { CompoundTypeReference result = owner.newCompoundTypeReference(reference.isSynonym()); boolean didSubstitute = false; for(LightweightTypeReference component: reference.getMultiTypeComponents()) { SubstitutionResult visited = visitTypeArgument(component, varianceInfo); result.addComponent(visited.typeReference); didSubstitute = didSubstitute || visited.didSubstitute; } return new SubstitutionResult(result, didSubstitute); }
@Override public LightweightTypeReference getRawTypeReference() { if (isAllRawType()) { return this; } CompoundTypeReference result = getOwner().newCompoundTypeReference(isSynonym()); for(LightweightTypeReference component: expose(components)) { result.addComponent(component.getRawTypeReference()); } return result; }
@Override protected LightweightTypeReference doVisitCompoundTypeReference(CompoundTypeReference reference, Visiting visiting) { if (reference.isResolved() && reference.isOwnedBy(getOwner())) return reference; CompoundTypeReference result = getOwner().newCompoundTypeReference(reference.isSynonym()); for(LightweightTypeReference component: reference.getMultiTypeComponents()) { result.addComponent(visitTypeArgument(component, visiting)); } return result; }