private PsiMethod generateDelegate(final PsiMethod methodToReplaceIn)
throws IncorrectOperationException {
final PsiMethod delegate = (PsiMethod) methodToReplaceIn.copy();
final PsiElementFactory elementFactory =
JavaPsiFacade.getInstance(myManager.getProject()).getElementFactory();
ChangeSignatureProcessor.makeEmptyBody(elementFactory, delegate);
final PsiCallExpression callExpression =
ChangeSignatureProcessor.addDelegatingCallTemplate(delegate, delegate.getName());
final PsiExpressionList argumentList = callExpression.getArgumentList();
assert argumentList != null;
final PsiParameter[] psiParameters = methodToReplaceIn.getParameterList().getParameters();
final PsiParameter anchorParameter = getAnchorParameter(methodToReplaceIn);
if (psiParameters.length == 0) {
argumentList.add(myParameterInitializer);
} else {
if (anchorParameter == null) {
argumentList.add(myParameterInitializer);
}
for (int i = 0; i < psiParameters.length; i++) {
PsiParameter psiParameter = psiParameters[i];
if (!myParametersToRemove.contains(i)) {
final PsiExpression expression =
elementFactory.createExpressionFromText(psiParameter.getName(), delegate);
argumentList.add(expression);
}
if (psiParameter == anchorParameter) {
argumentList.add(myParameterInitializer);
}
}
}
return (PsiMethod)
methodToReplaceIn.getContainingClass().addBefore(delegate, methodToReplaceIn);
}
@NotNull
public List<String> createConversions(@NotNull PsiCallExpression expression) {
PsiExpressionList argumentList = expression.getArgumentList();
PsiExpression[] arguments =
argumentList != null ? argumentList.getExpressions() : new PsiExpression[] {};
List<String> conversions = new LinkedList<String>();
//noinspection UnusedDeclaration
for (PsiExpression a : arguments) {
conversions.add("");
}
PsiMethod resolve = expression.resolveMethod();
if (resolve != null) {
List<PsiType> expectedTypes = new LinkedList<PsiType>();
List<PsiType> actualTypes = new LinkedList<PsiType>();
for (PsiParameter p : resolve.getParameterList().getParameters())
expectedTypes.add(p.getType());
for (PsiExpression e : arguments) actualTypes.add(e.getType());
if (conversions.size() == actualTypes.size() && actualTypes.size() == expectedTypes.size()) {
for (int i = 0; i < actualTypes.size(); i++)
conversions.set(i, createConversionForExpression(arguments[i], expectedTypes.get(i)));
}
}
return conversions;
}
@Override
protected Nullness create(MethodCallInstruction key) {
final PsiCallExpression callExpression = key.getCallExpression();
if (callExpression instanceof PsiNewExpression) {
return Nullness.NOT_NULL;
}
return callExpression != null
? DfaPsiUtil.getElementNullability(
key.getResultType(), callExpression.resolveMethod())
: null;
}
private static void checkCall(
@NotNull PsiCallExpression methodCall, @NotNull ProblemsHolder holder) {
PsiMethod method = methodCall.resolveMethod();
if (method == null) return;
PsiParameter[] parameters = method.getParameterList().getParameters();
PsiExpression[] arguments = methodCall.getArgumentList().getExpressions();
for (int i = 0; i < parameters.length; i++) {
PsiParameter parameter = parameters[i];
AllowedValues values = getAllowedValues(parameter, parameter.getType(), null);
if (values == null) continue;
if (i >= arguments.length) break;
PsiExpression argument = arguments[i];
argument = PsiUtil.deparenthesizeExpression(argument);
if (argument == null) continue;
checkMagicParameterArgument(parameter, argument, values, holder);
}
}
private static boolean isTrivial(PsiStatement body, PsiParameter parameter) {
final PsiIfStatement ifStatement = extractIfStatement(body);
// filter
if (ifStatement != null) {
return false;
}
// method reference
final PsiCallExpression callExpression =
LambdaCanBeMethodReferenceInspection.canBeMethodReferenceProblem(
body instanceof PsiBlockStatement ? ((PsiBlockStatement) body).getCodeBlock() : body,
new PsiParameter[] {parameter},
createDefaultConsumerType(parameter.getProject(), parameter));
if (callExpression == null) {
return true;
}
final PsiMethod method = callExpression.resolveMethod();
return method != null && isThrowsCompatible(method);
}
private static void addDelegateArguments(
JavaChangeInfo changeInfo, PsiElementFactory factory, final PsiCallExpression callExpression)
throws IncorrectOperationException {
final JavaParameterInfo[] newParms = changeInfo.getNewParameters();
final String[] oldParameterNames = changeInfo.getOldParameterNames();
for (int i = 0; i < newParms.length; i++) {
JavaParameterInfo newParm = newParms[i];
final PsiExpression actualArg;
if (newParm.getOldIndex() >= 0) {
actualArg =
factory.createExpressionFromText(
oldParameterNames[newParm.getOldIndex()], callExpression);
} else {
actualArg = changeInfo.getValue(i, callExpression);
}
JavaCodeStyleManager.getInstance(callExpression.getProject())
.shortenClassReferences(callExpression.getArgumentList().add(actualArg));
}
}
private boolean isTestOnlyMethodCalled(PsiCallExpression e) {
return isAnnotatedAsTestOnly(e.resolveMethod());
}
private boolean isUnderTestSources(PsiCallExpression e) {
ProjectRootManager rm = ProjectRootManager.getInstance(e.getProject());
VirtualFile f = e.getContainingFile().getVirtualFile();
if (f == null) return false;
return rm.getFileIndex().isInTestSourceContent(f);
}
public static void processNonArrayExpression(
ClassInstanceReferenceVisitor visitor,
PsiExpression expression,
PsiElement referencedElement) {
expression = RefactoringUtil.outermostParenthesizedExpression(expression);
PsiElement parent = expression.getParent();
if (parent instanceof PsiReferenceExpression
&& expression == ((PsiReferenceExpression) parent).getQualifierExpression()) {
visitor.visitQualifier((PsiReferenceExpression) parent, expression, referencedElement);
} else if (parent instanceof PsiTypeCastExpression) {
visitor.visitTypeCast((PsiTypeCastExpression) parent, expression, referencedElement);
} else if (parent instanceof PsiReturnStatement) {
final PsiReturnStatement returnStatement = (PsiReturnStatement) parent;
PsiElement enclosingMethod =
PsiTreeUtil.getParentOfType(returnStatement, PsiMethod.class, PsiLambdaExpression.class);
final PsiType returnType;
if (enclosingMethod instanceof PsiMethod) {
returnType = ((PsiMethod) enclosingMethod).getReturnType();
} else {
returnType = null;
}
visitor.visitReadUsage(expression, returnType, referencedElement);
} else if (parent instanceof PsiStatement) {
visitor.visitReadUsage(expression, null, referencedElement);
} else if (parent instanceof PsiExpressionList) {
PsiExpressionList expressionList = (PsiExpressionList) parent;
PsiElement pparent = expressionList.getParent();
if (pparent instanceof PsiStatement) {
visitor.visitReadUsage(expression, null, referencedElement);
} else if (pparent instanceof PsiCallExpression) {
PsiCallExpression callExpression = (PsiCallExpression) pparent;
PsiExpression[] arguments = callExpression.getArgumentList().getExpressions();
PsiMethod method = callExpression.resolveMethod();
if (method != null) {
int index = -1;
for (int i = 0; i < arguments.length; i++) {
PsiExpression argument = arguments[i];
if (argument.equals(expression)) {
index = i;
break;
}
}
if (index >= 0) {
PsiParameter[] parameters = method.getParameterList().getParameters();
if (parameters.length > index) {
visitor.visitReadUsage(expression, parameters[index].getType(), referencedElement);
}
}
}
}
} else if (parent instanceof PsiAssignmentExpression) {
PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression) parent;
if (expression.equals(assignmentExpression.getRExpression())) {
visitor.visitReadUsage(
expression, assignmentExpression.getLExpression().getType(), referencedElement);
} else { // LExpression
visitor.visitWriteUsage(
expression, assignmentExpression.getRExpression().getType(), referencedElement);
}
} else if (RefactoringUtil.isAssignmentLHS(expression)) {
visitor.visitWriteUsage(expression, null, referencedElement);
} else if (parent instanceof PsiVariable) {
visitor.visitReadUsage(expression, ((PsiVariable) parent).getType(), referencedElement);
} else if (parent instanceof PsiExpression) {
// for usages in expressions other than above, we do not care about the type
visitor.visitReadUsage(expression, null, referencedElement);
} else {
LOG.error("Unknown variation of class instance usage");
}
}
public PsiElement findTargetMember(PsiElement element) {
if (PsiTreeUtil.getParentOfType(element, PsiParameterList.class) != null) {
return PsiTreeUtil.getParentOfType(element, PsiMethod.class);
}
final PsiTypeParameterList typeParameterList =
PsiTreeUtil.getParentOfType(element, PsiTypeParameterList.class);
if (typeParameterList != null) {
return PsiTreeUtil.getParentOfType(typeParameterList, PsiMember.class);
}
final PsiElement elementParent = element.getParent();
if (elementParent instanceof PsiMethod
&& ((PsiMethod) elementParent).getNameIdentifier() == element) {
return elementParent;
}
if (elementParent instanceof PsiClass
&& ((PsiClass) elementParent).getNameIdentifier() == element) {
return elementParent;
}
final PsiCallExpression expression =
PsiTreeUtil.getParentOfType(element, PsiCallExpression.class);
if (expression != null) {
final PsiExpression qualifierExpression;
if (expression instanceof PsiMethodCallExpression) {
qualifierExpression =
((PsiMethodCallExpression) expression).getMethodExpression().getQualifierExpression();
} else if (expression instanceof PsiNewExpression) {
qualifierExpression = ((PsiNewExpression) expression).getQualifier();
} else {
qualifierExpression = null;
}
if (PsiTreeUtil.isAncestor(qualifierExpression, element, false)) {
final PsiExpressionList expressionList =
PsiTreeUtil.getParentOfType(qualifierExpression, PsiExpressionList.class);
if (expressionList != null) {
final PsiElement parent = expressionList.getParent();
if (parent instanceof PsiCallExpression) {
return ((PsiCallExpression) parent).resolveMethod();
}
}
} else {
return expression.resolveMethod();
}
}
final PsiReferenceParameterList referenceParameterList =
PsiTreeUtil.getParentOfType(element, PsiReferenceParameterList.class);
if (referenceParameterList != null) {
final PsiJavaCodeReferenceElement referenceElement =
PsiTreeUtil.getParentOfType(referenceParameterList, PsiJavaCodeReferenceElement.class);
if (referenceElement != null) {
final PsiElement resolved = referenceElement.resolve();
if (resolved instanceof PsiClass) {
return resolved;
} else if (resolved instanceof PsiMethod) {
return resolved;
}
}
}
return null;
}
