protected void resolveAgainstConstraints() { TypeParameterByConstraintSubstitutor unboundSubstitutor = new TypeParameterByConstraintSubstitutor( Collections.<JvmTypeParameter, LightweightMergedBoundTypeArgument>emptyMap(), getOwner(), true); LightweightTypeReference substitute = unboundSubstitutor.substitute(getOwner().newParameterizedTypeReference(typeParameter)); getOwner().acceptHint(getHandle(), new LightweightBoundTypeArgument(substitute, BoundTypeArgumentSource.RESOLVED, this, VarianceInfo.INVARIANT, VarianceInfo.INVARIANT)); resolvedTo = substitute; }
public List<LightweightBoundTypeArgument> getAllHints() { if (internalGetResolvedTo() != null) { throw new IllegalStateException("Cannot query hints for a resolved reference"); } return getOwner().getAllHints(getHandle()); }
public LightweightTypeReference internalGetResolvedTo() { if (resolvedTo != null) { if (!getOwner().isResolved(handle)) { throw new IllegalStateException("owner should know that this one is resolved"); } return resolvedTo; } if (getOwner().isResolved(getHandle())) { List<LightweightBoundTypeArgument> hints = getOwner().getAllHints(getHandle()); if (hints.isEmpty()) { throw new IllegalStateException("cannot have empty hints if marked as resolved"); } if (hints.size() != 1) return null; LightweightBoundTypeArgument singleHint = hints.get(0); if (singleHint.getSource() == BoundTypeArgumentSource.RESOLVED) { resolvedTo = singleHint.getTypeReference(); if (!getOwner().isResolved(handle)) { throw new IllegalStateException("owner should know that this one is resolved"); } return resolvedTo; } } return null; }
@Override protected List<JvmType> doVisitUnboundTypeReference(UnboundTypeReference reference, ResourceSet resourceSet) { List<LightweightBoundTypeArgument> hints = reference.getAllHints(); if (!hints.isEmpty()) { if (reference.resolveWithHints(hints)) { LightweightTypeReference resolvedTo = reference.getResolvedTo(); if (resolvedTo != null) return resolvedTo.accept(this, resourceSet); } } JvmTypeParameter typeParameter = reference.getTypeParameter(); return getRawTypesFromConstraints(reference.getOwner(), typeParameter, resourceSet); }
public void acceptHint(LightweightBoundTypeArgument hint) { if (internalIsResolved()) { throw new IllegalStateException("Cannot add hints to a resolved reference"); } if (hint.getSource() == BoundTypeArgumentSource.EXPLICIT) { LightweightTypeReference reference = hint.getTypeReference(); if (!(reference instanceof ParameterizedTypeReference) && !reference.isArray() && !reference.isUnknown()) { throw new IllegalArgumentException("cannot set " + hint + " as explicit hint"); } if (!getAllHints().isEmpty()) { throw new IllegalStateException("Cannot set explicit hint if other hints are present: " + getAllHints()); } this.resolvedTo = reference; getOwner().acceptHint(getHandle(), new LightweightBoundTypeArgument(resolvedTo, BoundTypeArgumentSource.RESOLVED, this, hint.getDeclaredVariance(), hint.getActualVariance())); return; } getOwner().acceptHint(this.getHandle(), hint); }
protected void propageResolvedTypeToConstraints(List<LightweightBoundTypeArgument> hints) { if (!resolvedTo.isRawType()) { for(LightweightBoundTypeArgument hint: hints) { LightweightTypeReference hintReference = hint.getTypeReference(); if (hintReference != null && !hintReference.isRawType() && hint.getSource() == BoundTypeArgumentSource.CONSTRAINT) { DeferredTypeParameterHintCollector collector = new DeferredTypeParameterHintCollector(getOwner()) { @Override protected BoundTypeArgumentSource getTypeArgumentSource() { return BoundTypeArgumentSource.INFERRED_CONSTRAINT; } @Override protected void addHint(UnboundTypeReference typeParameter, LightweightTypeReference reference) { if (typeParameter.getHandle() != getHandle()) super.addHint(typeParameter, reference); } }; collector.processPairedReferences(hintReference, resolvedTo); } } } }
LightweightMergedBoundTypeArgument typeArgument = getServices().getBoundTypeArgumentMerger().merge(!inferredHints.isEmpty() ? inferredHints : effectiveHints, getOwner()); if (typeArgument != null) { resolvedTo = typeArgument.getTypeReference(); getOwner().acceptHint(getHandle(), new LightweightBoundTypeArgument( resolvedTo, BoundTypeArgumentSource.RESOLVED,
unbound.acceptHint(unbound.getOwner().newParameterizedTypeReference(unbound.getTypeParameter()), BoundTypeArgumentSource.RESOLVED, unbound, VarianceInfo.INVARIANT, VarianceInfo.INVARIANT);