private static boolean isCollectCall(PsiStatement body, final PsiParameter parameter) {
PsiIfStatement ifStatement = extractIfStatement(body);
final PsiMethodCallExpression methodCallExpression = extractAddCall(body, ifStatement);
if (methodCallExpression != null) {
final PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression();
final PsiExpression qualifierExpression = methodExpression.getQualifierExpression();
PsiClass qualifierClass = null;
if (qualifierExpression instanceof PsiReferenceExpression) {
if (ReferencesSearch.search(parameter, new LocalSearchScope(qualifierExpression))
.findFirst()
!= null) {
return false;
}
final PsiElement resolve = ((PsiReferenceExpression) qualifierExpression).resolve();
if (resolve instanceof PsiVariable) {
if (ReferencesSearch.search(
resolve, new LocalSearchScope(methodCallExpression.getArgumentList()))
.findFirst()
!= null) {
return false;
}
}
qualifierClass = PsiUtil.resolveClassInType(qualifierExpression.getType());
} else if (qualifierExpression == null) {
final PsiClass enclosingClass = PsiTreeUtil.getParentOfType(body, PsiClass.class);
if (PsiUtil.getEnclosingStaticElement(body, enclosingClass) == null) {
qualifierClass = enclosingClass;
}
}
if (qualifierClass != null
&& InheritanceUtil.isInheritor(
qualifierClass, false, CommonClassNames.JAVA_UTIL_COLLECTION)) {
while (ifStatement != null && PsiTreeUtil.isAncestor(body, ifStatement, false)) {
final PsiExpression condition = ifStatement.getCondition();
if (condition != null
&& isConditionDependsOnUpdatedCollections(condition, qualifierExpression))
return false;
ifStatement = PsiTreeUtil.getParentOfType(ifStatement, PsiIfStatement.class);
}
final PsiElement resolve = methodExpression.resolve();
if (resolve instanceof PsiMethod
&& "add".equals(((PsiMethod) resolve).getName())
&& ((PsiMethod) resolve).getParameterList().getParametersCount() == 1) {
final PsiExpression[] args = methodCallExpression.getArgumentList().getExpressions();
if (args.length == 1) {
if (args[0] instanceof PsiCallExpression) {
final PsiMethod method = ((PsiCallExpression) args[0]).resolveMethod();
return method != null && !method.hasTypeParameters() && !isThrowsCompatible(method);
}
return true;
}
}
}
}
return false;
}
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
try {
PsiBinaryExpression binaryExpression = (PsiBinaryExpression) descriptor.getPsiElement();
IElementType opSign = binaryExpression.getOperationSign().getTokenType();
PsiExpression lExpr = binaryExpression.getLOperand();
PsiExpression rExpr = binaryExpression.getROperand();
if (rExpr == null) return;
PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory();
PsiMethodCallExpression equalsCall =
(PsiMethodCallExpression) factory.createExpressionFromText("a.equals(b)", null);
equalsCall.getMethodExpression().getQualifierExpression().replace(lExpr);
equalsCall.getArgumentList().getExpressions()[0].replace(rExpr);
PsiExpression result = (PsiExpression) binaryExpression.replace(equalsCall);
if (opSign == JavaTokenType.NE) {
PsiPrefixExpression negation =
(PsiPrefixExpression) factory.createExpressionFromText("!a", null);
negation.getOperand().replace(result);
result.replace(negation);
}
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
@Override
public void visitMethodCallExpression(PsiMethodCallExpression expression) {
super.visitMethodCallExpression(expression);
final PsiReferenceExpression methodExpression = expression.getMethodExpression();
@NonNls final String name = methodExpression.getReferenceName();
if (HardcodedMethodConstants.TO_STRING.equals(name)) {
final PsiExpressionList argumentList = expression.getArgumentList();
final PsiExpression[] arguments = argumentList.getExpressions();
if (arguments.length != 0) {
return;
}
final PsiExpression qualifier = methodExpression.getQualifierExpression();
checkExpression(qualifier);
} else if ("append".equals(name)) {
final PsiExpression qualifier = methodExpression.getQualifierExpression();
if (!TypeUtils.expressionHasTypeOrSubtype(
qualifier, CommonClassNames.JAVA_LANG_ABSTRACT_STRING_BUILDER)) {
return;
}
final PsiExpressionList argumentList = expression.getArgumentList();
final PsiExpression[] arguments = argumentList.getExpressions();
if (arguments.length != 1) {
return;
}
final PsiExpression argument = arguments[0];
checkExpression(argument);
} else if ("valueOf".equals(name)) {
final PsiExpression qualifierExpression = methodExpression.getQualifierExpression();
if (!(qualifierExpression instanceof PsiReferenceExpression)) {
return;
}
final PsiReferenceExpression referenceExpression =
(PsiReferenceExpression) qualifierExpression;
final String canonicalText = referenceExpression.getCanonicalText();
if (!CommonClassNames.JAVA_LANG_STRING.equals(canonicalText)) {
return;
}
final PsiExpressionList argumentList = expression.getArgumentList();
final PsiExpression[] arguments = argumentList.getExpressions();
if (arguments.length != 1) {
return;
}
final PsiExpression argument = arguments[0];
checkExpression(argument);
}
}
private static boolean isAddAllCall(PsiForeachStatement statement, PsiStatement body) {
final PsiIfStatement ifStatement = extractIfStatement(body);
if (ifStatement == null) {
final PsiParameter parameter = statement.getIterationParameter();
final PsiMethodCallExpression methodCallExpression = extractAddCall(body, null);
LOG.assertTrue(methodCallExpression != null);
return isIdentityMapping(
parameter, methodCallExpression.getArgumentList().getExpressions()[0]);
}
return false;
}
@Override
public void visitReferenceExpression(PsiReferenceExpression expression) {
if (argumentsContainCatchParameter || !visited.add(expression)) {
return;
}
super.visitReferenceExpression(expression);
final PsiElement target = expression.resolve();
if (!parameter.equals(target)) {
if (target instanceof PsiLocalVariable) {
final PsiLocalVariable variable = (PsiLocalVariable) target;
final Query<PsiReference> query =
ReferencesSearch.search(variable, variable.getUseScope(), false);
query.forEach(
reference -> {
final PsiElement element = reference.getElement();
final PsiElement parent =
PsiTreeUtil.skipParentsOfType(element, PsiParenthesizedExpression.class);
if (!(parent instanceof PsiReferenceExpression)) {
return true;
}
final PsiElement grandParent = parent.getParent();
if (!(grandParent instanceof PsiMethodCallExpression)) {
return true;
}
final PsiMethodCallExpression methodCallExpression =
(PsiMethodCallExpression) grandParent;
final PsiExpressionList argumentList = methodCallExpression.getArgumentList();
final PsiExpression[] arguments = argumentList.getExpressions();
for (PsiExpression argument : arguments) {
argument.accept(ReferenceFinder.this);
}
return true;
});
final PsiExpression initializer = variable.getInitializer();
if (initializer != null) {
initializer.accept(this);
}
}
return;
}
if (ignoreGetMessage) {
argumentsContainCatchParameter = true;
} else {
final PsiElement parent = expression.getParent();
if (parent instanceof PsiReferenceExpression) {
final PsiElement grandParent = parent.getParent();
if (grandParent instanceof PsiMethodCallExpression) {
return;
}
}
argumentsContainCatchParameter = true;
}
}
private boolean isListGetLookup(
PsiElement element, String indexName, PsiVariable listVariable) {
if (!(element instanceof PsiExpression)) {
return false;
}
final PsiExpression expression = (PsiExpression) element;
if (!expressionIsListGetLookup(expression)) {
return false;
}
final PsiMethodCallExpression methodCallExpression =
(PsiMethodCallExpression) ParenthesesUtils.stripParentheses(expression);
if (methodCallExpression == null) {
return false;
}
final PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression();
final PsiExpression qualifierExpression = methodExpression.getQualifierExpression();
final PsiExpressionList argumentList = methodCallExpression.getArgumentList();
final PsiExpression[] expressions = argumentList.getExpressions();
if (expressions.length != 1) {
return false;
}
if (!indexName.equals(expressions[0].getText())) {
return false;
}
if (qualifierExpression == null
|| qualifierExpression instanceof PsiThisExpression
|| qualifierExpression instanceof PsiSuperExpression) {
return listVariable == null;
}
if (!(qualifierExpression instanceof PsiReferenceExpression)) {
return false;
}
final PsiReferenceExpression referenceExpression =
(PsiReferenceExpression) qualifierExpression;
final PsiExpression qualifier = referenceExpression.getQualifierExpression();
if (qualifier != null
&& !(qualifier instanceof PsiThisExpression)
&& !(qualifier instanceof PsiSuperExpression)) {
return false;
}
final PsiElement target = referenceExpression.resolve();
return listVariable.equals(target);
}
private static String computeConstantSuperCtorCallParameter(
PsiClass languagePsiClass, int index) {
if (languagePsiClass instanceof PsiAnonymousClass) {
return getStringConstantExpression(
((PsiAnonymousClass) languagePsiClass).getArgumentList(), index);
}
PsiMethod defaultConstructor = null;
for (PsiMethod constructor : languagePsiClass.getConstructors()) {
if (constructor.getParameterList().getParametersCount() == 0) {
defaultConstructor = constructor;
break;
}
}
if (defaultConstructor == null) {
return null;
}
final PsiCodeBlock body = defaultConstructor.getBody();
if (body == null) {
return null;
}
final PsiStatement[] statements = body.getStatements();
if (statements.length < 1) {
return null;
}
// super() must be first
PsiStatement statement = statements[0];
if (!(statement instanceof PsiExpressionStatement)) {
return null;
}
PsiExpression expression = ((PsiExpressionStatement) statement).getExpression();
if (!(expression instanceof PsiMethodCallExpression)) {
return null;
}
PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) expression;
PsiExpressionList expressionList = methodCallExpression.getArgumentList();
return getStringConstantExpression(expressionList, index);
}
private boolean isIteratorNext(PsiElement element, String iteratorName, PsiType contentType) {
if (element == null) {
return false;
}
if (element instanceof PsiTypeCastExpression) {
final PsiTypeCastExpression castExpression = (PsiTypeCastExpression) element;
final PsiType type = castExpression.getType();
if (type == null) {
return false;
}
if (!type.equals(contentType)) {
return false;
}
final PsiExpression operand = castExpression.getOperand();
return isIteratorNext(operand, iteratorName, contentType);
}
if (!(element instanceof PsiMethodCallExpression)) {
return false;
}
final PsiMethodCallExpression callExpression = (PsiMethodCallExpression) element;
final PsiExpressionList argumentList = callExpression.getArgumentList();
final PsiExpression[] args = argumentList.getExpressions();
if (args.length != 0) {
return false;
}
final PsiReferenceExpression reference = callExpression.getMethodExpression();
final PsiExpression qualifier = reference.getQualifierExpression();
if (qualifier == null) {
return false;
}
if (!iteratorName.equals(qualifier.getText())) {
return false;
}
final String referenceName = reference.getReferenceName();
return HardcodedMethodConstants.NEXT.equals(referenceName);
}
public static void prepareWizardData(final WizardData data, PsiClass boundClass)
throws MyException {
final PsiMethod[] allGetDataMethods = boundClass.findMethodsByName("getData", false);
final PsiMethod[] allSetDataMethods = boundClass.findMethodsByName("setData", false);
PsiMethod setDataMethod = null;
PsiClass beanClass = null;
// find get/set pair and bean class
outer:
for (int i = 0; i < allGetDataMethods.length; i++) {
final PsiMethod _getMethod = allGetDataMethods[i];
if (_getMethod.getReturnType() != PsiType.VOID) {
continue;
}
final PsiParameter[] _getMethodParameters = _getMethod.getParameterList().getParameters();
if (_getMethodParameters.length != 1) {
continue;
}
final PsiClass _getParameterClass = getClassByType(_getMethodParameters[0].getType());
if (_getParameterClass == null) {
continue;
}
for (final PsiMethod _setMethod : allSetDataMethods) {
if (_setMethod.getReturnType() != PsiType.VOID) {
continue;
}
final PsiParameter[] _setMethodParameters = _setMethod.getParameterList().getParameters();
if (_setMethodParameters.length != 1) {
continue;
}
final PsiClass _setParameterClass = getClassByType(_setMethodParameters[0].getType());
if (_setParameterClass != _getParameterClass) {
continue;
}
// pair found !!!
setDataMethod = _setMethod;
beanClass = _getParameterClass;
break outer;
}
}
if (beanClass == null) {
// nothing found
return;
}
data.myBindToNewBean = false;
data.myBeanClass = beanClass;
// parse setData() and try to associate fields with bean
{
final PsiCodeBlock body = setDataMethod.getBody();
if (body == null) {
return;
}
final PsiElement[] children = body.getChildren();
for (PsiElement child : children) {
// Parses sequences like: a.foo(b.bar());
final PsiField bindingField;
if (!(child instanceof PsiExpressionStatement)) {
continue;
}
final PsiExpression expression = ((PsiExpressionStatement) child).getExpression();
if (!(expression instanceof PsiMethodCallExpression)) {
continue;
}
final PsiMethodCallExpression callExpression = (PsiMethodCallExpression) expression;
// find binding field ('a')
int index = -1;
{
final PsiElement psiElement = getObjectForWhichMethodWasCalled(callExpression);
if (!(psiElement instanceof PsiField)) {
continue;
}
if (((PsiField) psiElement).getContainingClass() != boundClass) {
continue;
}
bindingField = (PsiField) psiElement;
// find binding for this field
final FormProperty2BeanProperty[] bindings = data.myBindings;
for (int j = 0; j < bindings.length; j++) {
final FormProperty2BeanProperty binding = bindings[j];
if (bindingField
.getName()
.equals(binding.myFormProperty.getLwComponent().getBinding())) {
index = j;
break;
}
}
}
if (index == -1) {
continue;
}
// find 'bar()'
{
final PsiReferenceParameterList parameterList =
callExpression.getMethodExpression().getParameterList();
if (parameterList == null) {
continue;
}
final PsiExpressionList argumentList = callExpression.getArgumentList();
if (argumentList == null) {
continue;
}
final PsiExpression[] expressions = argumentList.getExpressions();
if (expressions == null || expressions.length != 1) {
continue;
}
if (!(expressions[0] instanceof PsiMethodCallExpression)) {
continue;
}
final PsiMethodCallExpression callExpression2 =
((PsiMethodCallExpression) expressions[0]);
// check that 'b' is parameter
final PsiElement psiElement = getObjectForWhichMethodWasCalled(callExpression2);
if (!(psiElement instanceof PsiParameter)) {
continue;
}
final PsiMethod barMethod = ((PsiMethod) callExpression2.getMethodExpression().resolve());
if (barMethod == null) {
continue;
}
if (!PropertyUtil.isSimplePropertyGetter(barMethod)) {
continue;
}
final String propertyName = PropertyUtil.getPropertyName(barMethod);
// There are two possible types: boolean and java.lang.String
String typeName = barMethod.getReturnType().getCanonicalText();
if (!"boolean".equals(typeName) && !"java.lang.String".equals(typeName)) {
continue;
}
data.myBindings[index].myBeanProperty = new BeanProperty(propertyName, typeName);
}
}
}
}
@NotNull
private List<PsiMethod> getMethodsToImport() {
PsiShortNamesCache cache = PsiShortNamesCache.getInstance(myMethodCall.getProject());
PsiMethodCallExpression element = myMethodCall.getElement();
PsiReferenceExpression reference = element.getMethodExpression();
PsiExpressionList argumentList = element.getArgumentList();
String name = reference.getReferenceName();
List<PsiMethod> list = new ArrayList<PsiMethod>();
if (name == null) return list;
GlobalSearchScope scope = element.getResolveScope();
PsiMethod[] methods = cache.getMethodsByNameIfNotMoreThan(name, scope, 20);
List<PsiMethod> applicableList = new ArrayList<PsiMethod>();
final PsiResolveHelper resolveHelper =
JavaPsiFacade.getInstance(element.getProject()).getResolveHelper();
for (PsiMethod method : methods) {
ProgressManager.checkCanceled();
if (JavaCompletionUtil.isInExcludedPackage(method)) continue;
if (!method.hasModifierProperty(PsiModifier.STATIC)) continue;
PsiFile file = method.getContainingFile();
if (file instanceof PsiJavaFile
// do not show methods from default package
&& ((PsiJavaFile) file).getPackageName().length() != 0
&& PsiUtil.isAccessible(method, element, method.getContainingClass())) {
list.add(method);
PsiSubstitutor substitutorForMethod =
resolveHelper.inferTypeArguments(
method.getTypeParameters(),
method.getParameterList().getParameters(),
argumentList.getExpressions(),
PsiSubstitutor.EMPTY,
element.getParent(),
DefaultParameterTypeInferencePolicy.INSTANCE);
if (PsiUtil.isApplicable(method, substitutorForMethod, argumentList)) {
applicableList.add(method);
}
}
}
List<PsiMethod> result = applicableList.isEmpty() ? list : applicableList;
for (int i = result.size() - 1; i >= 0; i--) {
ProgressManager.checkCanceled();
PsiMethod method = result.get(i);
PsiClass containingClass = method.getContainingClass();
for (int j = i + 1; j < result.size(); j++) {
PsiMethod exMethod = result.get(j);
if (!Comparing.strEqual(exMethod.getName(), method.getName())) continue;
PsiClass exContainingClass = exMethod.getContainingClass();
if (containingClass != null
&& exContainingClass != null
&& !Comparing.equal(
containingClass.getQualifiedName(), exContainingClass.getQualifiedName())) continue;
// same named methods, drop one
result.remove(i);
break;
}
// check for manually excluded
if (isExcluded(method)) {
result.remove(i);
}
}
Collections.sort(result, new PsiProximityComparator(argumentList));
return result;
}
@Override
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
final PsiForeachStatement foreachStatement =
PsiTreeUtil.getParentOfType(descriptor.getPsiElement(), PsiForeachStatement.class);
if (foreachStatement != null) {
if (!FileModificationService.getInstance().preparePsiElementForWrite(foreachStatement))
return;
final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project);
PsiStatement body = foreachStatement.getBody();
final PsiExpression iteratedValue = foreachStatement.getIteratedValue();
if (body != null && iteratedValue != null) {
final PsiParameter parameter = foreachStatement.getIterationParameter();
final PsiIfStatement ifStatement = extractIfStatement(body);
final PsiMethodCallExpression methodCallExpression = extractAddCall(body, ifStatement);
if (methodCallExpression == null) return;
if (isAddAllCall(foreachStatement, body)) {
restoreComments(foreachStatement, body);
final PsiExpression qualifierExpression =
methodCallExpression.getMethodExpression().getQualifierExpression();
final String qualifierText =
qualifierExpression != null ? qualifierExpression.getText() : "";
final String callText =
StringUtil.getQualifiedName(
qualifierText, "addAll(" + getIteratedValueText(iteratedValue) + ");");
PsiElement result =
foreachStatement.replace(
elementFactory.createStatementFromText(callText, foreachStatement));
reformatWhenNeeded(project, result);
return;
}
final StringBuilder builder =
new StringBuilder(getIteratedValueText(iteratedValue) + ".stream()");
builder.append(createFiltersChainText(body, parameter, ifStatement));
builder.append(
createMapperFunctionalExpressionText(
parameter, methodCallExpression.getArgumentList().getExpressions()[0]));
builder.append(".collect(java.util.stream.Collectors.");
PsiElement result = null;
try {
final PsiExpression qualifierExpression =
methodCallExpression.getMethodExpression().getQualifierExpression();
if (qualifierExpression instanceof PsiReferenceExpression) {
final PsiElement resolve = ((PsiReferenceExpression) qualifierExpression).resolve();
if (resolve instanceof PsiVariable) {
if (resolve instanceof PsiLocalVariable
&& foreachStatement.equals(
PsiTreeUtil.skipSiblingsForward(
resolve.getParent(), PsiWhiteSpace.class))) {
final PsiExpression initializer = ((PsiVariable) resolve).getInitializer();
if (initializer instanceof PsiNewExpression) {
final PsiExpressionList argumentList =
((PsiNewExpression) initializer).getArgumentList();
if (argumentList != null && argumentList.getExpressions().length == 0) {
restoreComments(foreachStatement, body);
final String callText =
builder.toString()
+ createInitializerReplacementText(
((PsiVariable) resolve).getType(), initializer)
+ ")";
result =
initializer.replace(
elementFactory.createExpressionFromText(callText, null));
simplifyRedundantCast(result);
foreachStatement.delete();
return;
}
}
}
}
}
restoreComments(foreachStatement, body);
final String qualifierText =
qualifierExpression != null ? qualifierExpression.getText() : "";
final String callText =
StringUtil.getQualifiedName(
qualifierText, "addAll(" + builder.toString() + "toList()));");
result =
foreachStatement.replace(
elementFactory.createStatementFromText(callText, foreachStatement));
simplifyRedundantCast(result);
} finally {
reformatWhenNeeded(project, result);
}
}
}
}