/*
To declare or not a variable to which method call result will be assigned.
*/
private static List<VariableInfo> mustAddVariableDeclaration(
@NotNull GrStatement[] statements, @NotNull VariableInfo[] vars) {
Map<String, VariableInfo> names = new HashMap<String, VariableInfo>();
for (VariableInfo var : vars) {
names.put(var.getName(), var);
}
List<VariableInfo> result = new ArrayList<VariableInfo>();
for (GrStatement statement : statements) {
if (statement instanceof GrVariableDeclaration) {
GrVariableDeclaration declaration = (GrVariableDeclaration) statement;
for (GrVariable variable : declaration.getVariables()) {
final VariableInfo removed = names.remove(variable.getName());
if (removed != null) {
result.add(removed);
}
}
}
}
for (String varName : names.keySet()) {
if (ResolveUtil.resolveProperty(statements[0], varName) == null) {
result.add(names.get(varName));
}
}
return result;
}
public GrInplaceConstantIntroducer(
GrIntroduceContext context, OccurrencesChooser.ReplaceChoice choice) {
super(IntroduceConstantHandler.REFACTORING_NAME, choice, context);
myContext = context;
myPanel = new GrInplaceIntroduceConstantPanel();
GrVariable localVar = GrIntroduceHandlerBase.resolveLocalVar(context);
if (localVar != null) {
ArrayList<String> result = ContainerUtil.newArrayList(localVar.getName());
GrExpression initializer = localVar.getInitializerGroovy();
if (initializer != null) {
ContainerUtil.addAll(
result,
GroovyNameSuggestionUtil.suggestVariableNames(
initializer, new GroovyInplaceFieldValidator(context), true));
}
mySuggestedNames = ArrayUtil.toStringArray(result);
} else {
GrExpression expression = context.getExpression();
assert expression != null;
mySuggestedNames =
GroovyNameSuggestionUtil.suggestVariableNames(
expression, new GroovyInplaceFieldValidator(context), true);
}
}
@Override
protected void checkVariable(@NotNull GrVariable variable) throws GrRefactoringError {
final GrExpression initializer = variable.getInitializerGroovy();
if (initializer == null) {
throw new GrRefactoringError(
RefactoringBundle.message("variable.does.not.have.an.initializer", variable.getName()));
}
checkExpression(initializer);
}
private void flushForeachLoopVariable(@Nullable GrForClause clause) {
if (clause instanceof GrForInClause) {
GrVariable variable = clause.getDeclaredVariable();
if (variable != null && myPolicy.isVariableInitialized(variable)) {
addNodeAndCheckPending(
new ReadWriteVariableInstruction(variable.getName(), variable, WRITE));
}
}
}
public void visitVariable(GrVariable variable) {
super.visitVariable(variable);
if (myPolicy.isVariableInitialized(variable)) {
ReadWriteVariableInstruction writeInst =
new ReadWriteVariableInstruction(variable.getName(), variable, WRITE);
addNodeAndCheckPending(writeInst);
}
}
private NameSuggestionsField createNameField(GrVariable var) {
List<String> names = new ArrayList<String>();
if (var != null) {
names.add(var.getName());
}
ContainerUtil.addAll(names, suggestNames());
return new NameSuggestionsField(
ArrayUtil.toStringArray(names), myProject, GroovyFileType.GROOVY_FILE_TYPE);
}
private static boolean variablesAreEquivalent(
@NotNull GrVariable var1, @NotNull GrVariable var2) {
final GrExpression initializer1 = (GrExpression) var1.getInitializer();
final GrExpression initializer2 = (GrExpression) var2.getInitializer();
if (!expressionsAreEquivalent(initializer1, initializer2)) {
return false;
}
final PsiType type1 = var1.getType();
final PsiType type2 = var2.getType();
if (!typesAreEquivalent(type1, type2)) {
return false;
}
final String name1 = var1.getName();
final String name2 = var2.getName();
if (name1 == null) {
return name2 == null;
}
return name1.equals(name2);
}
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 void writeTupleDeclaration(
GrVariableDeclaration variableDeclaration,
StringBuilder builder,
ExpressionContext expressionContext) {
GrVariable[] variables = variableDeclaration.getVariables();
final GrExpression tupleInitializer = variableDeclaration.getTupleInitializer();
if (tupleInitializer instanceof GrListOrMap) {
for (GrVariable variable : variables) {
writeVariableSeparately(variable, builder, expressionContext);
builder.append(";\n");
}
} else if (tupleInitializer != null) {
GroovyResolveResult iteratorMethodResult =
resolveMethod(
tupleInitializer,
"iterator",
GrExpression.EMPTY_ARRAY,
GrNamedArgument.EMPTY_ARRAY,
GrClosableBlock.EMPTY_ARRAY,
variableDeclaration);
final PsiType iteratorType = inferIteratorType(iteratorMethodResult, tupleInitializer);
final String iteratorName =
genIteratorVar(
variableDeclaration,
builder,
expressionContext,
tupleInitializer,
iteratorType,
iteratorMethodResult);
final GrModifierList modifierList = variableDeclaration.getModifierList();
PsiType iterableTypeParameter = PsiUtil.extractIterableTypeParameter(iteratorType, false);
for (final GrVariable v : variables) {
ModifierListGenerator.writeModifiers(builder, modifierList);
final PsiType type = context.typeProvider.getVarType(v);
writeType(builder, type, variableDeclaration);
builder.append(' ').append(v.getName());
builder.append(" = ");
wrapInCastIfNeeded(
builder,
type,
iterableTypeParameter,
tupleInitializer,
expressionContext,
new StatementWriter() {
@Override
public void writeStatement(StringBuilder builder, ExpressionContext context) {
builder
.append(iteratorName)
.append(".hasNext() ? ")
.append(iteratorName)
.append(".next() : null");
}
});
builder.append(";\n");
}
} else {
writeSimpleVarDeclaration(variableDeclaration, builder, expressionContext);
}
}
private static void writeVariableWithoutSemicolonAndInitializer(
StringBuilder builder, GrVariable var, ExpressionContext context) {
ModifierListGenerator.writeModifiers(builder, var.getModifierList());
writeType(builder, context.typeProvider.getVarType(var), var);
builder.append(' ').append(var.getName());
}
