/** * Try to resolve this reference iff there are hints available. * May be invoked multiple times since it will simply returns if * the reference is already resolved. * * This is fully equivalent to {@code tryResolve(true)}. * * @see #tryResolve(boolean) */ public void tryResolve() { tryResolve(true); }
protected void tryResolveUnboundReferences() { for (UnboundTypeReference unbound : basicGetTypeParameters().values()) { if (unbound.getExpression() == expression) { // resolve all type parameters of the expression that // have already been annotated with significant hints // the type constraints themselves are not considered to // be significant 'enough' unbound.tryResolve(false); } } }
@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 void doVisitUnboundTypeReference(UnboundTypeReference reference, ArrayTypeReference declaration) { if (reference.internalIsResolved() || getOwner().isResolved(reference.getHandle())) { reference.tryResolve(); outerVisit(reference, declaration); } else { addHint(reference, declaration); } } }
@Override protected LightweightTypeReference doVisitUnboundTypeReference(UnboundTypeReference reference, Object param) { if (reference.internalIsResolved()) { return super.doVisitUnboundTypeReference(reference, param); } else { List<LightweightBoundTypeArgument> hints = reference.getAllHints(); for (LightweightBoundTypeArgument hint : hints) { BoundTypeArgumentSource source = hint.getSource(); if (source == BoundTypeArgumentSource.INFERRED || source == BoundTypeArgumentSource.EXPECTATION || source == BoundTypeArgumentSource.INFERRED_CONSTRAINT) { reference.tryResolve(); if (reference.internalIsResolved()) { return reference.accept(this, param); } } } } return reference; }
@Override protected void acceptHint(UnboundTypeReference reference, LightweightTypeReference param) { if (!shouldProcess(reference.getTypeParameter())) { reference.tryResolve(); if (reference.internalIsResolved()) { outerVisit(reference, param); } else { super.acceptHint(reference, param); } } else { reference.acceptHint(boundByInference(param)); } }
@Override protected void doVisitTypeReference(LightweightTypeReference reference, UnboundTypeReference declaration) { if (declaration.internalIsResolved() || getOwner().isResolved(declaration.getHandle())) { declaration.tryResolve(); outerVisit(declaration, reference, declaration, getExpectedVariance(), getActualVariance()); } else { acceptHint(declaration, reference); } }
@Override protected void doVisitUnboundTypeReference(UnboundTypeReference reference, UnboundTypeReference declaration) { if (declaration.internalIsResolved() || getOwner().isResolved(declaration.getHandle())) { declaration.tryResolve(); outerVisit(declaration, reference, declaration, getExpectedVariance(), getActualVariance()); } else { if (getParametersToProcess().contains(declaration.getTypeParameter()) && VarianceInfo.OUT == getActualVariance() && VarianceInfo.OUT == getExpectedVariance()) { if (getDefaultSource() == BoundTypeArgumentSource.EXPECTATION) { List<LightweightBoundTypeArgument> hints = reference.getAllHints(); for(int i = 0; i < hints.size(); i++) { if (hints.get(i).getSource() == BoundTypeArgumentSource.INFERRED) { return; } } } } acceptHint(declaration, reference); } }
@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); } }
@Override protected void doVisitTypeReference(LightweightTypeReference reference, UnboundTypeReference declaration) { if (declaration.internalIsResolved() || getOwner().isResolved(declaration.getHandle())) { declaration.tryResolve(); outerVisit(declaration, reference, declaration, getExpectedVariance(), getActualVariance()); } else { processTypeParameter(declaration.getTypeParameter(), reference); } }
List<JvmTypeParameter> typeParameters = basicGetDeclardTypeParameters(); if (typeParameters != null && typeParameters.contains(unbound.getTypeParameter())) { unbound.tryResolve(); if (!unbound.internalIsResolved()) { if (unbound.getExpression() instanceof XConstructorCall) {
protected int doIsConformant(LightweightTypeReference left, UnboundTypeReference right, int flags) { if (left.getType() == right.getType() || left.isType(Object.class)) { return flags | SUCCESS; } if ((flags & ALLOW_UNBOXING) == 0 && left.isPrimitive()) { return flags; } boolean doesNotHaveSignificantHints = false; if (((flags & RAW_TYPE) == 0) && (right.canResolveTo(left) || (flags & AS_TYPE_ARGUMENT) != 0 && (doesNotHaveSignificantHints = !right.hasSignificantHints()))) { if ((flags & UNBOUND_COMPUTATION_ADDS_HINTS) != 0 && doesNotHaveSignificantHints) { right.acceptHint(left, BoundTypeArgumentSource.INFERRED_LATER, left, VarianceInfo.INVARIANT, VarianceInfo.INVARIANT); } return flags | SUCCESS; } right.tryResolve(false); LightweightTypeReference resolvedTo = right.getResolvedTo(); if (resolvedTo != null) { return doIsConformant(left, resolvedTo, flags); } return flags; }
@Override public void doVisitUnboundTypeReference(UnboundTypeReference reference, WildcardTypeReference declaration) { if (declaration.getLowerBound() == null) { if (!reference.internalIsResolved()) { List<LightweightTypeReference> upperBounds = declaration.getUpperBounds(); for(LightweightTypeReference upperBound: upperBounds) { if (!upperBound.isResolved() || !reference.canResolveTo(upperBound)) { super.doVisitUnboundTypeReference(reference, declaration); return; } } reference.tryResolve(); if (reference.internalIsResolved()) { outerVisit(reference, declaration); } else { addHint(reference, declaration); } return; } } super.doVisitUnboundTypeReference(reference, declaration); } }
reference.acceptHint(declaration, BoundTypeArgumentSource.INFERRED, this, VarianceInfo.INVARIANT, VarianceInfo.INVARIANT); } else { reference.tryResolve(); if (reference.internalIsResolved()) { outerVisit(reference, declaration);
reference.acceptHint(declaration, BoundTypeArgumentSource.INFERRED, this, VarianceInfo.INVARIANT, VarianceInfo.INVARIANT); } else { reference.tryResolve(); if (reference.internalIsResolved()) { outerVisit(reference, declaration);