@Override
public void visitMethodCallExpression(GrMethodCallExpression grMethodCallExpression) {
super.visitMethodCallExpression(grMethodCallExpression);
final GrArgumentList args = grMethodCallExpression.getArgumentList();
if (args.getExpressionArguments().length != 1) {
return;
}
if (PsiImplUtil.hasNamedArguments(args)) {
return;
}
final GrExpression methodExpression = grMethodCallExpression.getInvokedExpression();
if (!(methodExpression instanceof GrReferenceExpression)) {
return;
}
final GrReferenceExpression referenceExpression = (GrReferenceExpression) methodExpression;
final String name = referenceExpression.getReferenceName();
if (!"get".equals(name)) {
return;
}
final GrExpression qualifier = referenceExpression.getQualifierExpression();
if (qualifier == null || PsiUtil.isThisOrSuperRef(qualifier)) {
return;
}
if (referenceExpression.getDotTokenType() == GroovyTokenTypes.mOPTIONAL_DOT) return;
final PsiType type = qualifier.getType();
if (!InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_UTIL_MAP)) {
return;
}
registerMethodCallError(grMethodCallExpression);
}
public boolean satisfiedBy(PsiElement element) {
if (element instanceof GrMethodCallExpression) {
final GrMethodCallExpression expression = (GrMethodCallExpression) element;
// final PsiElement parent = expression.getParent();
// if (parent instanceof GrAssignmentExpression) return false;
// if (parent instanceof GrArgumentList) return false;
// if (parent instanceof GrReturnStatement) return false;
// if (!(parent instanceof GrCodeBlock || parent instanceof GrIfStatement|| parent
// instanceof GrCaseSection)) return false;
final GrExpression invokedExpression = expression.getInvokedExpression();
if (invokedExpression instanceof GrReferenceExpression) {
GrReferenceExpression referenceExpression = (GrReferenceExpression) invokedExpression;
if ("each".equals(referenceExpression.getReferenceName())) {
final GrArgumentList argumentList = expression.getArgumentList();
if (argumentList != null) {
if (PsiImplUtil.hasExpressionArguments(argumentList)) return false;
if (PsiImplUtil.hasNamedArguments(argumentList)) return false;
}
final GrClosableBlock[] closureArguments = expression.getClosureArguments();
if (closureArguments.length != 1) return false;
final GrParameter[] parameters = closureArguments[0].getParameterList().getParameters();
if (parameters.length > 1) return false;
return true;
}
}
}
return false;
}
@Override
protected void processIntention(@NotNull PsiElement element, Project project, Editor editor)
throws IncorrectOperationException {
final GrMethodCallExpression expression = (GrMethodCallExpression) element;
final GrClosableBlock block = expression.getClosureArguments()[0];
final GrParameterList parameterList = block.getParameterList();
final GrParameter[] parameters = parameterList.getParameters();
String var;
if (parameters.length == 1) {
var = parameters[0].getText();
var = StringUtil.replace(var, GrModifier.DEF, "");
} else {
var = "it";
}
final GrExpression invokedExpression = expression.getInvokedExpression();
GrExpression qualifier = ((GrReferenceExpression) invokedExpression).getQualifierExpression();
final GroovyPsiElementFactory elementFactory =
GroovyPsiElementFactory.getInstance(element.getProject());
if (qualifier == null) {
qualifier = elementFactory.createExpressionFromText("this");
}
StringBuilder builder = new StringBuilder();
builder.append("for (").append(var).append(" in ").append(qualifier.getText()).append(") {\n");
String text = block.getText();
final PsiElement blockArrow = block.getArrow();
int index;
if (blockArrow != null) {
index = blockArrow.getStartOffsetInParent() + blockArrow.getTextLength();
} else {
index = 1;
}
while (index < text.length() && Character.isWhitespace(text.charAt(index))) index++;
text = text.substring(index, text.length() - 1);
builder.append(text);
builder.append("}");
final GrStatement statement = elementFactory.createStatementFromText(builder.toString());
GrForStatement forStatement = (GrForStatement) expression.replaceWithStatement(statement);
final GrForClause clause = forStatement.getClause();
GrVariable variable = clause.getDeclaredVariable();
forStatement = updateReturnStatements(forStatement);
if (variable == null) return;
if (ApplicationManager.getApplication().isUnitTestMode()) return;
final PsiDocumentManager documentManager = PsiDocumentManager.getInstance(project);
final Document doc = documentManager.getDocument(element.getContainingFile());
if (doc == null) return;
documentManager.doPostponedOperationsAndUnblockDocument(doc);
editor.getCaretModel().moveToOffset(variable.getTextOffset());
new VariableInplaceRenamer(variable, editor).performInplaceRename();
}
@Override
public void doFix(Project project, ProblemDescriptor descriptor)
throws IncorrectOperationException {
final PsiElement referenceName = descriptor.getPsiElement();
final GrReferenceExpression invokedExpression =
(GrReferenceExpression) referenceName.getParent();
final GrMethodCallExpression callExpression =
(GrMethodCallExpression) invokedExpression.getParent();
final GrArgumentList args = callExpression.getArgumentList();
final GrExpression arg = args.getExpressionArguments()[0];
replaceExpression(
callExpression,
invokedExpression.getQualifierExpression().getText() + '[' + arg.getText() + ']');
}
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;
}
});
}
@Override
public boolean satisfiedBy(PsiElement element) {
if (!(element instanceof GrMethodCallExpression)) {
return false;
}
final GrMethodCallExpression call = (GrMethodCallExpression) element;
final GrExpression invokedExpression = call.getInvokedExpression();
if (invokedExpression == null) {
return false;
}
final PsiType type = invokedExpression.getType();
if (type == null) {
return false;
}
if (!type.equalsToText(GroovyCommonClassNames.GROOVY_LANG_CLOSURE)) {
return false;
}
return !ErrorUtil.containsError(element);
}
@NotNull
private static GrStatement[] createResultStatement(ExtractInfoHelper helper) {
VariableInfo[] outputVars = helper.getOutputVariableInfos();
PsiType type = helper.getOutputType();
GrStatement[] statements = helper.getStatements();
GrMethodCallExpression callExpression = createMethodCall(helper);
if ((outputVars.length == 0 || PsiType.VOID.equals(type)) && !helper.hasReturnValue())
return new GrStatement[] {callExpression};
GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(helper.getProject());
if (helper.hasReturnValue()) {
return new GrStatement[] {
factory.createStatementFromText("return " + callExpression.getText())
};
}
LOG.assertTrue(outputVars.length > 0);
final List<VariableInfo> mustAdd = mustAddVariableDeclaration(statements, outputVars);
if (mustAdd.size() == 0) {
return new GrStatement[] {createAssignment(outputVars, callExpression, helper.getProject())};
} else if (mustAdd.size() == outputVars.length && outputVars.length == 1) {
return new GrVariableDeclaration[] {
factory.createVariableDeclaration(
ArrayUtil.EMPTY_STRING_ARRAY,
callExpression,
outputVars[0].getType(),
outputVars[0].getName())
};
} else if (varsAreEqual(mustAdd, outputVars)) {
return createTupleDeclaration(outputVars, callExpression, helper.getProject());
} else {
final List<GrStatement> result = generateVarDeclarations(mustAdd, helper.getProject(), null);
result.add(createAssignment(outputVars, callExpression, helper.getProject()));
return result.toArray(new GrStatement[result.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()]);
}
}
}
public static void processChangedMethodCall(
PsiElement element, GrIntroduceParameterSettings settings, Project project) {
if (!(element.getParent() instanceof GrMethodCallExpression)) {
LOG.error(element.getParent());
return;
}
GrMethodCallExpression methodCall = (GrMethodCallExpression) element.getParent();
GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(project);
final String name = settings.getName();
LOG.assertTrue(name != null);
GrExpression expression = factory.createExpressionFromText(name, null);
final GrArgumentList argList = methodCall.getArgumentList();
final PsiElement[] exprs = argList.getAllArguments();
if (exprs.length > 0) {
argList.addAfter(expression, exprs[exprs.length - 1]);
} else {
argList.add(expression);
}
removeParametersFromCall(methodCall, settings);
}
private static GrStatement createAssignment(
VariableInfo[] infos, GrMethodCallExpression callExpression, final Project project) {
StringBuilder text = new StringBuilder();
if (infos.length > 1) text.append('(');
for (VariableInfo info : infos) {
text.append(info.getName()).append(", ");
}
if (infos.length > 1) {
text.replace(text.length() - 2, text.length(), ") =");
} else {
text.replace(text.length() - 2, text.length(), " = ");
}
text.append(callExpression.getText());
return GroovyPsiElementFactory.getInstance(project).createExpressionFromText(text.toString());
}
private static GrStatement[] createTupleDeclaration(
final VariableInfo[] infos, GrMethodCallExpression callExpression, final Project project) {
GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(project);
StringBuilder tuple = new StringBuilder();
tuple.append("def (");
for (VariableInfo info : infos) {
final PsiType type = info.getType();
if (type != null) {
final PsiType unboxed = TypesUtil.unboxPrimitiveTypeWrapper(type);
tuple.append(unboxed.getCanonicalText());
tuple.append(' ');
}
tuple.append(info.getName());
tuple.append(",");
}
StringUtil.trimEnd(tuple, ",");
tuple.append(")=");
tuple.append(callExpression.getText());
return new GrStatement[] {factory.createStatementFromText(tuple)};
}