/** * @param lowerBound if the given reference was used as the lower bound of a wildcard */ protected LightweightTypeReference visitTypeArgument(LightweightTypeReference reference, Visiting visiting, boolean lowerBound) { return reference.accept(this, visiting); }
protected boolean visit(List<LightweightTypeReference> list) { for(LightweightTypeReference arg: list) { if (!arg.accept(this)) { return false; } } return true; } }
@Override protected void doVisitArrayTypeReference(ArrayTypeReference declaredReference, LightweightTypeReference param) { param.accept(arrayTypeReferenceTraverser, declaredReference); }
protected List<JvmType> collectRawTypes(List<LightweightTypeReference> references, ResourceSet resourceSet) { List<JvmType> result = Lists.newArrayList(); for(LightweightTypeReference component: references) { result.addAll(component.accept(this, resourceSet)); } return result; }
protected void enhanceCompoundReference(List<LightweightTypeReference> references, CompoundTypeReference result, ResourceSet resourceSet) { if (references.isEmpty()) { throw new IllegalStateException("References may not be empty"); } for(LightweightTypeReference component: references) { result.addComponent(component.accept(this, resourceSet)); } }
@Override public LightweightTypeReference substitute(LightweightTypeReference original) { return original.accept(this, createVisiting()); } }.substitute(operationParameterType);
@Override protected LightweightTypeReference doVisitSynonymTypeReference(CompoundTypeReference reference, ResourceSet resourceSet) { if (reference.isRawType()) return reference; List<LightweightTypeReference> components = reference.getMultiTypeComponents(); return components.get(components.size() - 1).accept(this, resourceSet); }
protected LightweightTypeReference getBoundTypeArgument(ParameterizedTypeReference reference, JvmTypeParameter type, Visiting visiting) { LightweightMergedBoundTypeArgument boundTypeArgument = typeParameterMapping.get(type); if (boundTypeArgument != null) { LightweightTypeReference boundReference = boundTypeArgument.getTypeReference(); if (boundReference != null && reference != boundReference && boundReference.getType() != type) { return boundReference.accept(this, visiting); } } return null; }
protected void doVisitCompoundTypeReference(CompoundTypeReference reference) { List<LightweightTypeReference> components = reference.getMultiTypeComponents(); if (components.isEmpty()) doVisitTypeReference(reference); else for (LightweightTypeReference component: components) { component.accept(this); } }
@Override protected void doVisitInnerTypeReference(InnerTypeReference reference, StringBuilder param) { reference.getOuter().accept(this, param); param.append("."); doVisitParameterizedTypeReference(reference, param); }
public Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> getTypeParameterMapping(LightweightTypeReference reference) { LightweightTraversalData data = new LightweightTraversalData(); reference.accept(this, data); return data.getTypeParameterMapping(); }
@Override protected void doVisitArrayTypeReference(final ArrayTypeReference reference) { reference.getComponentType().accept(this); this.appender.append("[]"); }
@Override /* @Nullable */ public <Param, Result> Result accept(TypeReferenceVisitorWithParameterAndResult<Param, Result> visitor, Param param) { if (internalIsResolved()) { return resolvedTo.accept(visitor, param); } else { return visitor.doVisitUnboundTypeReference(this, param); } }
@Override public <Param> void accept(TypeReferenceVisitorWithParameter<Param> visitor, Param param) { if (internalIsResolved()) { resolvedTo.accept(visitor, param); } else { visitor.doVisitUnboundTypeReference(this, param); } }
@Override /* @Nullable */ public <Result> Result accept(TypeReferenceVisitorWithResult<Result> visitor) { if (internalIsResolved()) { return resolvedTo.accept(visitor); } else { return visitor.doVisitUnboundTypeReference(this); } }
protected String _getStringRepresentation(final LightweightTypeReference object) { final StringBuilderBasedAppendable appender = new StringBuilderBasedAppendable(this.importManager); final LightweightTypeReferenceSerializer serializer = new LightweightTypeReferenceSerializer(appender); object.accept(serializer); return appender.toString(); }
@Override protected ArrayTypeReference doVisitArrayTypeReference(ArrayTypeReference reference, ResourceSet resourceSet) { if (reference.isRawType()) return reference; LightweightTypeReference componentType = reference.getComponentType(); LightweightTypeReference rawComponentType = componentType.accept(this, resourceSet); return reference.getOwner().newArrayTypeReference(rawComponentType); }
@Override protected LocalTypeSubstitutor.SubstitutionResult doVisitArrayTypeReference(ArrayTypeReference reference, VarianceInfo varianceInfo) { SubstitutionResult visited = reference.getComponentType().accept(this, varianceInfo); if (visited.didSubstitute) { return new SubstitutionResult(owner.newArrayTypeReference(visited.typeReference), true); } return new SubstitutionResult(reference, false); }
@Override protected LightweightTypeReference doVisitWildcardTypeReference(WildcardTypeReference reference, ResourceSet resourceSet) { if (reference.isUnbounded()) { return reference.getUpperBoundSubstitute(); } if (reference.getUpperBounds().size() == 1) { return reference.getUpperBoundSubstitute().accept(this, resourceSet); } CompoundTypeReference result = reference.getOwner().newCompoundTypeReference(false); enhanceCompoundReference(reference.getUpperBounds(), result, resourceSet); return result; }
@Override protected LightweightTypeReference doVisitInnerTypeReference(InnerTypeReference reference, Visiting visiting) { if (reference.isResolved() && reference.isOwnedBy(getOwner())) return reference; LightweightTypeReference outer = reference.getOuter().accept(this, visiting); ParameterizedTypeReference result = getOwner().newParameterizedTypeReference(outer, reference.getType()); for(LightweightTypeReference argument: reference.getTypeArguments()) { result.addTypeArgument(visitTypeArgument(argument, visiting)); } return result; }