public void merge(final Binding b, final boolean removeObject) {
for (final PsiTypeVariable var : b.getBoundVariables()) {
final int index = var.getIndex();
if (myBindings.get(index) != null) {
LOG.error("Oops... Binding conflict...");
} else {
final PsiType type = b.apply(var);
final PsiClassType javaLangObject =
PsiType.getJavaLangObject(
PsiManager.getInstance(myProject), GlobalSearchScope.allScope(myProject));
if (removeObject && javaLangObject.equals(type)) {
final HashSet<PsiTypeVariable> cluster = myFactory.getClusterOf(var.getIndex());
if (cluster != null) {
for (final PsiTypeVariable war : cluster) {
final PsiType wtype = b.apply(war);
if (!javaLangObject.equals(wtype)) {
myBindings.put(index, type);
break;
}
}
}
} else {
myBindings.put(index, type);
}
}
}
}
@Override
public void visitThrowStatement(PsiThrowStatement statement) {
super.visitThrowStatement(statement);
final PsiCatchSection catchSection =
PsiTreeUtil.getParentOfType(statement, PsiCatchSection.class, true, PsiClass.class);
if (catchSection == null) {
return;
}
final PsiParameter parameter = catchSection.getParameter();
if (parameter == null) {
return;
}
@NonNls final String parameterName = parameter.getName();
if (PsiUtil.isIgnoredName(parameterName)) {
return;
}
final PsiExpression exception = statement.getException();
if (exception == null) {
return;
}
if (ignoreCantWrap) {
final PsiType thrownType = exception.getType();
if (thrownType instanceof PsiClassType) {
final PsiClassType classType = (PsiClassType) thrownType;
final PsiClass exceptionClass = classType.resolve();
if (exceptionClass != null) {
final PsiMethod[] constructors = exceptionClass.getConstructors();
final PsiClassType throwableType =
TypeUtils.getType(CommonClassNames.JAVA_LANG_THROWABLE, statement);
boolean canWrap = false;
outer:
for (PsiMethod constructor : constructors) {
final PsiParameterList parameterList = constructor.getParameterList();
final PsiParameter[] parameters = parameterList.getParameters();
for (PsiParameter constructorParameter : parameters) {
final PsiType type = constructorParameter.getType();
if (throwableType.equals(type)) {
canWrap = true;
break outer;
}
}
}
if (!canWrap) {
return;
}
}
}
}
final ReferenceFinder visitor = new ReferenceFinder(parameter);
exception.accept(visitor);
if (visitor.usesParameter()) {
return;
}
registerStatementError(statement);
}
@Override
public void visitTypeCastExpression(@NotNull PsiTypeCastExpression expression) {
super.visitTypeCastExpression(expression);
final PsiExpression operand = expression.getOperand();
if (operand == null) {
return;
}
final PsiType operandType = operand.getType();
if (operandType == null) {
return;
}
final PsiType type = expression.getType();
if (type == null) {
return;
}
final PsiType expectedType = ExpectedTypeUtils.findExpectedType(expression, true);
if (expectedType == null) {
return;
}
if (expectedType.equals(type)) {
return;
}
final PsiClass resolved = PsiUtil.resolveClassInType(expectedType);
if (resolved != null && !resolved.isPhysical()) {
return;
}
if (expectedType.isAssignableFrom(operandType)) {
// then it's redundant, and caught by the built-in exception
return;
}
if (isTypeParameter(expectedType)) {
return;
}
if (expectedType instanceof PsiArrayType) {
final PsiArrayType arrayType = (PsiArrayType) expectedType;
final PsiType componentType = arrayType.getDeepComponentType();
if (isTypeParameter(componentType)) {
return;
}
}
if (type instanceof PsiPrimitiveType || expectedType instanceof PsiPrimitiveType) {
return;
}
if (PsiPrimitiveType.getUnboxedType(type) != null
|| PsiPrimitiveType.getUnboxedType(expectedType) != null) {
return;
}
if (expectedType instanceof PsiClassType) {
final PsiClassType expectedClassType = (PsiClassType) expectedType;
final PsiClassType expectedRawType = expectedClassType.rawType();
if (type.equals(expectedRawType)) {
return;
}
if (type instanceof PsiClassType) {
final PsiClassType classType = (PsiClassType) type;
final PsiClassType rawType = classType.rawType();
if (rawType.equals(expectedRawType)) {
return;
}
}
if (type instanceof PsiArrayType) {
return;
}
}
if (ignoreInMatchingInstanceof && InstanceOfUtils.hasAgreeingInstanceof(expression)) {
return;
}
final PsiTypeElement castTypeElement = expression.getCastType();
if (castTypeElement == null) {
return;
}
registerError(castTypeElement, expectedType);
}
