@NotNull
private static Set<PsiClassType> filterInProjectExceptions(
@Nullable PsiMethod targetMethod, @NotNull List<PsiClassType> unhandledExceptions) {
if (targetMethod == null) return Collections.emptySet();
Set<PsiClassType> result = new HashSet<PsiClassType>();
if (targetMethod.getManager().isInProject(targetMethod)) {
PsiMethod[] superMethods = targetMethod.findSuperMethods();
for (PsiMethod superMethod : superMethods) {
Set<PsiClassType> classTypes = filterInProjectExceptions(superMethod, unhandledExceptions);
result.addAll(classTypes);
}
if (superMethods.length == 0) {
result.addAll(unhandledExceptions);
}
} else {
PsiClassType[] referencedTypes = targetMethod.getThrowsList().getReferencedTypes();
for (PsiClassType referencedType : referencedTypes) {
PsiClass psiClass = referencedType.resolve();
if (psiClass == null) continue;
for (PsiClassType exception : unhandledExceptions) {
if (referencedType.isAssignableFrom(exception)) result.add(exception);
}
}
}
return result;
}
private static boolean hasSuperMethodsWithoutExceptions(
@NotNull PsiMethod[] superMethods, @NotNull Set<PsiClassType> unhandledExceptions) {
for (PsiMethod superMethod : superMethods) {
PsiClassType[] referencedTypes = superMethod.getThrowsList().getReferencedTypes();
Set<PsiClassType> exceptions = new HashSet<PsiClassType>(unhandledExceptions);
for (PsiClassType referencedType : referencedTypes) {
for (PsiClassType exception : unhandledExceptions) {
if (referencedType.isAssignableFrom(exception)) exceptions.remove(exception);
}
}
if (!exceptions.isEmpty()) return true;
}
return false;
}
public static Set<String> suggestExpressionOfType(
final PsiClassType type, final PsiLiteralExpression context) {
PsiVariable[] variables = MacroUtil.getVariablesVisibleAt(context, "");
Set<String> result = new LinkedHashSet<String>();
for (PsiVariable var : variables) {
PsiType varType = var.getType();
if (type == null || type.isAssignableFrom(varType)) {
result.add(var.getNameIdentifier().getText());
}
}
PsiExpression[] expressions = MacroUtil.getStandardExpressionsOfType(context, type);
for (PsiExpression expression : expressions) {
result.add(expression.getText());
}
if (type != null) {
addAvailableMethodsOfType(type, context, result);
}
return result;
}
