@Override /* @Nullable */ public LightweightTypeReference tryConvertToListType() { if (internalIsResolved()) { return resolvedTo.tryConvertToListType(); } return null; }
@Override public boolean isAny() { if (internalIsResolved()) { return resolvedTo.isAny(); } return false; }
@Override public boolean isPrimitive() { if (internalIsResolved()) { return resolvedTo.isPrimitive(); } return false; }
@Override public boolean isType(Class<?> clazz) { if (internalIsResolved()) { return resolvedTo.isType(clazz); } return false; }
@Override public boolean isArray() { if (internalIsResolved()) { return resolvedTo.isArray(); } return false; }
@Override public boolean isUnknown() { if (internalIsResolved()) { return resolvedTo.isUnknown(); } return false; }
@Override /* @Nullable */ public Primitive getPrimitiveKind() { if (internalIsResolved()) { return resolvedTo.getPrimitiveKind(); } return null; }
@Override public LightweightTypeReference getPrimitiveIfWrapperType() { if (internalIsResolved()) { return resolvedTo.getPrimitiveIfWrapperType(); } return this; }
@Override protected List<LightweightTypeReference> getSuperTypes(TypeParameterSubstitutor<?> substitutor) { if (internalIsResolved()) return resolvedTo.getSuperTypes(substitutor); return Collections.emptyList(); }
public boolean hasSignificantHints() { if (internalIsResolved()) return true; List<LightweightBoundTypeArgument> hints = getAllHints(); if (!hints.isEmpty() && hasSignificantHints(hints)) return true; return false; }
@Override /* @Nullable */ public ArrayTypeReference tryConvertToArray() { if (internalIsResolved()) { return resolvedTo.tryConvertToArray(); } return super.tryConvertToArray(); }
@Override /* @Nullable */ public JvmType getType() { if (internalIsResolved()) return resolvedTo.getType(); return getTypeParameter(); }
@Override public String getIdentifier() { if (internalIsResolved()) { return resolvedTo.getIdentifier(); } return "Unbound[" + typeParameter.getIdentifier() + "]"; }
@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 FunctionTypeKind getFunctionTypeKind() { if (internalIsResolved()) { return resolvedTo.getFunctionTypeKind(); } return super.getFunctionTypeKind(); }
@Override public <Param> void accept(TypeReferenceVisitorWithParameter<Param> visitor, Param param) { if (internalIsResolved()) { resolvedTo.accept(visitor, param); } else { visitor.doVisitUnboundTypeReference(this, param); } }
@Override public void doVisitUnboundTypeReference(UnboundTypeReference reference, ArrayTypeReference declaration) { if (reference.internalIsResolved() || getOwner().isResolved(reference.getHandle())) { reference.tryResolve(); outerVisit(reference, declaration); } else { addHint(reference, declaration); } } }
@Override public void doVisitUnboundTypeReference(UnboundTypeReference reference, ParameterizedTypeReference declaration) { if (reference.internalIsResolved() || getOwner().isResolved(reference.getHandle())) { reference.tryResolve(); outerVisit(reference, declaration); } else { addHint(reference, declaration); } } }
/** * Returns true if the existing hints would allow to resolve to the given reference. */ public boolean canResolveTo(LightweightTypeReference reference) { if (internalIsResolved()) return reference.isAssignableFrom(resolvedTo, new TypeConformanceComputationArgument(false, true, true, true, false, false /* TODO do we need to support synonmys here? */)); List<LightweightBoundTypeArgument> hints = getAllHints(); if (!hints.isEmpty() && hasSignificantHints(hints)) { return canResolveTo(reference, hints); } return false; }
@Override protected void doVisitTypeReference(LightweightTypeReference reference, UnboundTypeReference declaration) { if (declaration.internalIsResolved() || getOwner().isResolved(declaration.getHandle())) { declaration.tryResolve(); outerVisit(declaration, reference, declaration, getExpectedVariance(), getActualVariance()); } else if (reference.isValidHint()) { addHint(declaration, reference); } }