@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 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 LightweightTypeReference doVisitParameterizedTypeReference(ParameterizedTypeReference reference, ResourceSet resourceSet) { JvmType type = reference.getType(); if (reference.isRawType() && !(type instanceof JvmTypeParameter)) { return reference; } if (type instanceof JvmTypeParameter) { return getRawTypeFromConstraints(reference.getOwner(), (JvmTypeParameter) type, resourceSet); } return reference.getOwner().toPlainTypeReference(type); }
@Override public ParameterizedTypeReference toInstanceTypeReference() { ParameterizedTypeReference outerInstanceTypeReference = ((ParameterizedTypeReference) outer).toInstanceTypeReference(); InnerTypeReference result = getOwner().newParameterizedTypeReference(outerInstanceTypeReference, getType()); for(LightweightTypeReference typeArgument: getTypeArguments()) { result.addTypeArgument(typeArgument.getInvariantBoundSubstitute()); } return result; } }
@Override public LightweightTypeReference getRawTypeReference() { LightweightTypeReference rawComponent = component.getRawTypeReference(); if (rawComponent == component) { return this; } return getOwner().newArrayTypeReference(rawComponent); }
@Override public FunctionTypeKind getFunctionTypeKind() { for(LightweightTypeReference component: expose(components)) { if (component.isFunctionType()) { FunctionTypeKind kind = getFunctionTypeKind(); if (kind != FunctionTypeKind.NONE) { return kind; } } } return FunctionTypeKind.NONE; }
@Override public LightweightTypeReference getNamedType() { if (isAnonymous()) { return getOwner().newArrayTypeReference(component.getNamedType()); } return super.getNamedType(); }
@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); } }
@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 LightweightTypeReference enhance(ParameterizedTypeReference reference) { reference.addTypeArgument(owner.newWildcardTypeReference()); return reference; } });
@Override protected ParameterizedTypeReference doCopyInto(ITypeReferenceOwner owner) { LightweightTypeReference copiedOuter = outer.copyInto(owner); InnerTypeReference result = new InnerTypeReference(owner, copiedOuter, getType()); copyTypeArguments(result, owner); return result; }
@Override public void doVisitUnboundTypeReference(UnboundTypeReference reference, ParameterizedTypeReference declaration) { if (reference.internalIsResolved() || getOwner().isResolved(reference.getHandle())) { reference.tryResolve(); outerVisit(reference, declaration); } else { addHint(reference, declaration); } } }
@Override public boolean isArray() { if (internalIsResolved()) { return resolvedTo.isArray(); } return false; }
@Override /* @Nullable */ public Primitive getPrimitiveKind() { if (internalIsResolved()) { return resolvedTo.getPrimitiveKind(); } return null; }
@Override public boolean isUnknown() { if (internalIsResolved()) { return resolvedTo.isUnknown(); } return false; }
protected int addHintAndAnnounceSuccess(UnboundTypeReference left, LightweightTypeReference hint, int flags) { if (hint instanceof WildcardTypeReference) { List<LightweightTypeReference> bounds = ((WildcardTypeReference) hint).getUpperBounds(); for(LightweightTypeReference upperBound: bounds) left.acceptHint(upperBound, BoundTypeArgumentSource.INFERRED, this, VarianceInfo.OUT, VarianceInfo.OUT); } else { left.acceptHint(hint, BoundTypeArgumentSource.INFERRED, this, VarianceInfo.OUT, VarianceInfo.OUT); } return flags | SUCCESS; }
@Override public boolean isRawType() { if (internalGetResolvedTo() != null) return resolvedTo.isRawType(); return false; }