protected void collectAllVariablesOnBothSides(
Set<InferenceVariable> dependencies, Pair<PsiTypeParameter[], PsiClassType> capture) {
mySession.collectDependencies(capture.second, dependencies);
for (PsiTypeParameter psiTypeParameter : capture.first) {
final InferenceVariable var = mySession.getInferenceVariable(psiTypeParameter);
if (var != null) {
dependencies.add(var);
}
}
}
/** a = b imply every bound of a matches a bound of b and vice versa */
private boolean eqCrossVariables(InferenceVariable inferenceVariable, List<PsiType> eqBounds) {
boolean needFurtherIncorporation = false;
for (PsiType eqBound : eqBounds) {
final InferenceVariable inferenceVar = mySession.getInferenceVariable(eqBound);
if (inferenceVar != null) {
for (InferenceBound inferenceBound : InferenceBound.values()) {
for (PsiType bound : inferenceVariable.getBounds(inferenceBound)) {
if (mySession.getInferenceVariable(bound) != inferenceVar) {
needFurtherIncorporation |= inferenceVar.addBound(bound, inferenceBound);
}
}
for (PsiType bound : inferenceVar.getBounds(inferenceBound)) {
if (mySession.getInferenceVariable(bound) != inferenceVariable) {
needFurtherIncorporation |= inferenceVariable.addBound(bound, inferenceBound);
}
}
}
}
}
return needFurtherIncorporation;
}
/** a < b & S <: a & b <: T imply S <: b & a <: T */
private boolean crossVariables(
InferenceVariable inferenceVariable,
List<PsiType> upperBounds,
List<PsiType> lowerBounds,
InferenceBound inferenceBound) {
final InferenceBound oppositeBound =
inferenceBound == InferenceBound.LOWER ? InferenceBound.UPPER : InferenceBound.LOWER;
boolean result = false;
for (PsiType upperBound : upperBounds) {
final InferenceVariable inferenceVar = mySession.getInferenceVariable(upperBound);
if (inferenceVar != null && inferenceVariable != inferenceVar) {
for (PsiType lowerBound : lowerBounds) {
result |= inferenceVar.addBound(lowerBound, inferenceBound);
}
for (PsiType varUpperBound : inferenceVar.getBounds(oppositeBound)) {
result |= inferenceVariable.addBound(varUpperBound, oppositeBound);
}
}
}
return result;
}
public boolean incorporate() {
final Collection<InferenceVariable> inferenceVariables = mySession.getInferenceVariables();
final PsiSubstitutor substitutor =
mySession.retrieveNonPrimitiveEqualsBounds(inferenceVariables);
for (InferenceVariable inferenceVariable : inferenceVariables) {
if (inferenceVariable.getInstantiation() != PsiType.NULL) continue;
final List<PsiType> eqBounds = inferenceVariable.getBounds(InferenceBound.EQ);
final List<PsiType> upperBounds = inferenceVariable.getBounds(InferenceBound.UPPER);
final List<PsiType> lowerBounds = inferenceVariable.getBounds(InferenceBound.LOWER);
eqEq(eqBounds);
upDown(lowerBounds, upperBounds, substitutor);
upDown(eqBounds, upperBounds, substitutor);
upDown(lowerBounds, eqBounds, substitutor);
upUp(upperBounds);
}
for (Pair<PsiTypeParameter[], PsiClassType> capture : myCaptures) {
final PsiClassType right = capture.second;
final PsiClass gClass = right.resolve();
LOG.assertTrue(gClass != null);
final PsiTypeParameter[] parameters = capture.first;
PsiType[] typeArgs = right.getParameters();
if (parameters.length != typeArgs.length) continue;
for (int i = 0; i < typeArgs.length; i++) {
PsiType aType = typeArgs[i];
if (aType instanceof PsiCapturedWildcardType) {
aType = ((PsiCapturedWildcardType) aType).getWildcard();
}
final InferenceVariable inferenceVariable = mySession.getInferenceVariable(parameters[i]);
LOG.assertTrue(inferenceVariable != null);
final List<PsiType> eqBounds = inferenceVariable.getBounds(InferenceBound.EQ);
final List<PsiType> upperBounds = inferenceVariable.getBounds(InferenceBound.UPPER);
final List<PsiType> lowerBounds = inferenceVariable.getBounds(InferenceBound.LOWER);
if (aType instanceof PsiWildcardType) {
for (PsiType eqBound : eqBounds) {
if (!isInferenceVariableOrFreshTypeParameter(eqBound)) return false;
}
final PsiClassType[] paramBounds = inferenceVariable.getParameter().getExtendsListTypes();
PsiType glb = null;
for (PsiClassType paramBound : paramBounds) {
if (glb == null) {
glb = paramBound;
} else {
glb = GenericsUtil.getGreatestLowerBound(glb, paramBound);
}
}
if (!((PsiWildcardType) aType).isBounded()) {
for (PsiType upperBound : upperBounds) {
if (glb != null && mySession.getInferenceVariable(upperBound) == null) {
addConstraint(
new StrictSubtypingConstraint(
upperBound, mySession.substituteWithInferenceVariables(glb)));
}
}
for (PsiType lowerBound : lowerBounds) {
if (isInferenceVariableOrFreshTypeParameter(lowerBound)) return false;
}
} else if (((PsiWildcardType) aType).isExtends()) {
final PsiType extendsBound = ((PsiWildcardType) aType).getExtendsBound();
for (PsiType upperBound : upperBounds) {
if (mySession.getInferenceVariable(upperBound) == null) {
if (paramBounds.length == 1
&& paramBounds[0].equalsToText(CommonClassNames.JAVA_LANG_OBJECT)
|| paramBounds.length == 0) {
addConstraint(new StrictSubtypingConstraint(upperBound, extendsBound));
} else if (extendsBound.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)
&& glb != null) {
addConstraint(
new StrictSubtypingConstraint(
upperBound, mySession.substituteWithInferenceVariables(glb)));
}
}
}
for (PsiType lowerBound : lowerBounds) {
if (isInferenceVariableOrFreshTypeParameter(lowerBound)) return false;
}
} else {
LOG.assertTrue(((PsiWildcardType) aType).isSuper());
final PsiType superBound = ((PsiWildcardType) aType).getSuperBound();
for (PsiType upperBound : upperBounds) {
if (glb != null && mySession.getInferenceVariable(upperBound) == null) {
addConstraint(
new StrictSubtypingConstraint(
mySession.substituteWithInferenceVariables(glb), upperBound));
}
}
for (PsiType lowerBound : lowerBounds) {
if (mySession.getInferenceVariable(lowerBound) == null) {
addConstraint(new StrictSubtypingConstraint(lowerBound, superBound));
}
}
}
} else {
inferenceVariable.addBound(aType, InferenceBound.EQ);
}
}
}
return true;
}