public static GrStatement replaceStatement(
GrStatementOwner declarationOwner, ExtractInfoHelper helper) {
GrStatement realStatement;
if (declarationOwner != null && !isSingleExpression(helper.getStatements())) {
// Replace set of statements
final GrStatement[] newStatement = createResultStatement(helper);
// add call statement
final GrStatement[] statements = helper.getStatements();
LOG.assertTrue(statements.length > 0);
realStatement = null;
for (GrStatement statement : newStatement) {
realStatement = declarationOwner.addStatementBefore(statement, statements[0]);
GrReferenceAdjuster.shortenReferences(realStatement);
}
LOG.assertTrue(realStatement != null);
// remove old statements
removeOldStatements(declarationOwner, helper);
PsiImplUtil.removeNewLineAfter(realStatement);
} else {
// Expression call replace
GrExpression methodCall = createMethodCall(helper);
GrExpression oldExpr = (GrExpression) helper.getStatements()[0];
realStatement = oldExpr.replaceWithExpression(methodCall, true);
GrReferenceAdjuster.shortenReferences(realStatement);
}
return realStatement;
}
private static GrMethodCallExpression createMethodCall(ExtractInfoHelper helper) {
StringBuilder buffer = new StringBuilder();
buffer.append(helper.getName()).append("(");
int number = 0;
for (ParameterInfo info : helper.getParameterInfos()) {
if (info.passAsParameter()) number++;
}
int i = 0;
String[] argumentNames = helper.getArgumentNames();
for (String argName : argumentNames) {
if (argName.length() > 0) {
buffer.append(argName);
if (i < number - 1) {
buffer.append(",");
}
i++;
}
}
buffer.append(")");
String callText = buffer.toString();
GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(helper.getProject());
GrExpression expr = factory.createExpressionFromText(callText);
LOG.assertTrue(expr instanceof GrMethodCallExpression, callText);
return ((GrMethodCallExpression) expr);
}
public static String[] getParameterString(ExtractInfoHelper helper, boolean useCanonicalText) {
int i = 0;
ParameterInfo[] infos = helper.getParameterInfos();
int number = 0;
for (ParameterInfo info : infos) {
if (info.passAsParameter()) number++;
}
ArrayList<String> params = new ArrayList<String>();
for (ParameterInfo info : infos) {
if (info.passAsParameter()) {
PsiType paramType = info.getType();
final PsiPrimitiveType unboxed = PsiPrimitiveType.getUnboxedType(paramType);
if (unboxed != null) paramType = unboxed;
String paramTypeText;
if (paramType == null || paramType.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) {
paramTypeText = "";
} else {
paramTypeText =
(useCanonicalText ? paramType.getCanonicalText() : paramType.getPresentableText())
+ " ";
}
params.add(paramTypeText + info.getName() + (i < number - 1 ? ", " : ""));
i++;
}
}
return ArrayUtil.toStringArray(params);
}
@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 static void generateBody(
ExtractInfoHelper helper, boolean isVoid, StringBuilder buffer, boolean forceReturn) {
VariableInfo[] outputInfos = helper.getOutputVariableInfos();
ParameterInfo[] infos = helper.getParameterInfos();
Set<String> declaredVars = new HashSet<String>();
for (ParameterInfo info : infos) {
declaredVars.add(info.getName());
}
for (VariableInfo info : mustAddVariableDeclaration(helper.getStatements(), outputInfos)) {
declaredVars.add(info.getName());
}
List<VariableInfo> genDecl = new ArrayList<VariableInfo>();
final Collection<GrVariable> outside =
collectUsedLocalVarsOrParamsDeclaredOutside(helper.getStatements());
for (final GrVariable variable : outside) {
if (!declaredVars.contains(variable.getName())) {
genDecl.add(
new VariableInfo() {
@NotNull
@Override
public String getName() {
return variable.getName();
}
@Override
public PsiType getType() {
return variable.getDeclaredType();
}
});
}
}
final List<GrStatement> statements =
generateVarDeclarations(genDecl, helper.getProject(), null);
for (GrStatement statement : statements) {
buffer.append(statement.getText()).append('\n');
}
if (!isSingleExpression(helper.getStatements()) || statements.size() > 0) {
for (PsiElement element : helper.getInnerElements()) {
buffer.append(element.getText());
}
// append return statement
if (!isVoid && outputInfos.length > 0) {
buffer.append('\n');
if (forceReturn) {
buffer.append("return ");
}
if (outputInfos.length > 1) buffer.append('[');
for (VariableInfo info : outputInfos) {
buffer.append(info.getName()).append(", ");
}
buffer.delete(buffer.length() - 2, buffer.length());
if (outputInfos.length > 1) buffer.append(']');
}
} else {
GrExpression expr = (GrExpression) PsiUtil.skipParentheses(helper.getStatements()[0], false);
boolean addReturn = !isVoid && forceReturn;
if (addReturn) {
buffer.append("return ");
expr = ApplicationStatementUtil.convertToMethodCallExpression(expr);
buffer.append(expr.getText());
} else {
buffer.append(expr != null ? expr.getText() : "");
}
}
}
private static void removeOldStatements(GrStatementOwner owner, ExtractInfoHelper helper)
throws IncorrectOperationException {
owner.removeElements(helper.getInnerElements());
}
