private static void removeParametersFromCall(
GrMethodCallExpression methodCall, GrIntroduceParameterSettings settings) {
final GroovyResolveResult resolveResult = methodCall.advancedResolve();
final PsiElement resolved = resolveResult.getElement();
LOG.assertTrue(resolved instanceof PsiMethod);
final GrClosureSignature signature =
GrClosureSignatureUtil.createSignature(
(PsiMethod) resolved, resolveResult.getSubstitutor());
final GrClosureSignatureUtil.ArgInfo<PsiElement>[] argInfos =
GrClosureSignatureUtil.mapParametersToArguments(signature, methodCall);
LOG.assertTrue(argInfos != null);
settings
.parametersToRemove()
.forEach(
new TIntProcedure() {
@Override
public boolean execute(int value) {
final List<PsiElement> args = argInfos[value].args;
for (PsiElement arg : args) {
arg.delete();
}
return true;
}
});
}
public void visitArgumentList(GrArgumentList list) {
List<TypeConstraint> constraints = new ArrayList<TypeConstraint>();
for (GroovyResolveResult variant : ResolveUtil.getCallVariants(list)) {
final Map<GrExpression, Pair<PsiParameter, PsiType>> map =
GrClosureSignatureUtil.mapArgumentsToParameters(
variant,
list,
true,
true,
list.getNamedArguments(),
list.getExpressionArguments(),
GrClosableBlock.EMPTY_ARRAY);
addConstraintsFromMap(constraints, map);
}
if (!constraints.isEmpty()) {
myResult = constraints.toArray(new TypeConstraint[constraints.size()]);
}
}
public void visitMethodCallExpression(GrMethodCallExpression methodCall) {
final GrExpression invokedExpression = methodCall.getInvokedExpression();
if (myExpression.equals(invokedExpression)) {
myResult =
new TypeConstraint[] {
SubtypeConstraint.create(GroovyCommonClassNames.GROOVY_LANG_CLOSURE, methodCall)
};
return;
}
final GrClosableBlock[] closureArgs = methodCall.getClosureArguments();
//noinspection SuspiciousMethodCalls
final int closureIndex = Arrays.asList(closureArgs).indexOf(myExpression);
if (closureIndex >= 0) {
List<TypeConstraint> constraints = new ArrayList<TypeConstraint>();
for (GroovyResolveResult variant : ResolveUtil.getCallVariants(myExpression)) {
final GrArgumentList argumentList = methodCall.getArgumentList();
final GrNamedArgument[] namedArgs =
argumentList == null ? GrNamedArgument.EMPTY_ARRAY : argumentList.getNamedArguments();
final GrExpression[] expressionArgs =
argumentList == null
? GrExpression.EMPTY_ARRAY
: argumentList.getExpressionArguments();
try {
final Map<GrExpression, Pair<PsiParameter, PsiType>> map =
GrClosureSignatureUtil.mapArgumentsToParameters(
variant, methodCall, true, true, namedArgs, expressionArgs, closureArgs);
addConstraintsFromMap(constraints, map);
} catch (RuntimeException e) {
LOG.error(
"call: " + methodCall.getText() + "\nsymbol: " + variant.getElement().getText(), e);
}
}
if (!constraints.isEmpty()) {
myResult = constraints.toArray(new TypeConstraint[constraints.size()]);
}
}
}
@Override
protected void processIntention(@NotNull PsiElement element, Project project, Editor editor)
throws IncorrectOperationException {
final GrField field;
if (element.getParent() instanceof GrField) {
field = (GrField) element.getParent();
} else {
final PsiReference ref = element.getReference();
LOG.assertTrue(ref != null);
PsiElement resolved = ref.resolve();
if (resolved instanceof GrAccessorMethod) {
resolved = ((GrAccessorMethod) resolved).getProperty();
}
LOG.assertTrue(resolved instanceof GrField);
field = (GrField) resolved;
}
final HashSet<PsiReference> usages = new HashSet<PsiReference>();
usages.addAll(ReferencesSearch.search(field).findAll());
final GrAccessorMethod[] getters = field.getGetters();
for (GrAccessorMethod getter : getters) {
usages.addAll(MethodReferencesSearch.search(getter).findAll());
}
final GrAccessorMethod setter = field.getSetter();
if (setter != null) {
usages.addAll(MethodReferencesSearch.search(setter).findAll());
}
final String fieldName = field.getName();
LOG.assertTrue(fieldName != null);
final Collection<PsiElement> fieldUsages = new HashSet<PsiElement>();
MultiMap<PsiElement, String> conflicts = new MultiMap<PsiElement, String>();
for (PsiReference usage : usages) {
final PsiElement psiElement = usage.getElement();
if (PsiUtil.isMethodUsage(psiElement)) continue;
if (!GroovyFileType.GROOVY_LANGUAGE.equals(psiElement.getLanguage())) {
conflicts.putValue(
psiElement,
GroovyIntentionsBundle.message("closure.is.accessed.outside.of.groovy", fieldName));
} else {
if (psiElement instanceof GrReferenceExpression) {
fieldUsages.add(psiElement);
if (PsiUtil.isAccessedForWriting((GrExpression) psiElement)) {
conflicts.putValue(
psiElement,
GroovyIntentionsBundle.message("write.access.to.closure.variable", fieldName));
}
} else if (psiElement instanceof GrArgumentLabel) {
conflicts.putValue(
psiElement,
GroovyIntentionsBundle.message("field.is.used.in.argument.label", fieldName));
}
}
}
final PsiClass containingClass = field.getContainingClass();
final GrExpression initializer = field.getInitializerGroovy();
LOG.assertTrue(initializer != null);
final PsiType type = initializer.getType();
LOG.assertTrue(type instanceof GrClosureType);
final GrSignature signature = ((GrClosureType) type).getSignature();
final List<MethodSignature> signatures =
GrClosureSignatureUtil.generateAllMethodSignaturesBySignature(fieldName, signature);
for (MethodSignature s : signatures) {
final PsiMethod method = MethodSignatureUtil.findMethodBySignature(containingClass, s, true);
if (method != null) {
conflicts.putValue(
method,
GroovyIntentionsBundle.message(
"method.with.signature.already.exists",
GroovyPresentationUtil.getSignaturePresentation(s)));
}
}
if (conflicts.size() > 0) {
final ConflictsDialog conflictsDialog =
new ConflictsDialog(
project,
conflicts,
new Runnable() {
@Override
public void run() {
execute(field, fieldUsages);
}
});
conflictsDialog.show();
if (conflictsDialog.getExitCode() != DialogWrapper.OK_EXIT_CODE) return;
}
execute(field, fieldUsages);
}
