@Override
public String variableNameToPropertyName(String name, VariableKind variableKind) {
if (variableKind == VariableKind.STATIC_FINAL_FIELD
|| variableKind == VariableKind.STATIC_FIELD && name.contains("_")) {
StringBuilder buffer = new StringBuilder();
for (int i = 0; i < name.length(); i++) {
char c = name.charAt(i);
if (c != '_') {
if (Character.isLowerCase(c)) {
return variableNameToPropertyNameInner(name, variableKind);
}
buffer.append(Character.toLowerCase(c));
continue;
}
//noinspection AssignmentToForLoopParameter
i++;
if (i < name.length()) {
c = name.charAt(i);
buffer.append(c);
}
}
return buffer.toString();
}
return variableNameToPropertyNameInner(name, variableKind);
}
private void suggestNamesFromGenericParameters(
final PsiType type,
final VariableKind variableKind,
final Collection<String> suggestions,
boolean correctKeywords) {
if (!(type instanceof PsiClassType)) {
return;
}
StringBuilder fullNameBuilder = new StringBuilder();
final PsiType[] parameters = ((PsiClassType) type).getParameters();
for (PsiType parameter : parameters) {
if (parameter instanceof PsiClassType) {
final String typeName = normalizeTypeName(getTypeName(parameter));
if (typeName != null) {
fullNameBuilder.append(typeName);
}
}
}
String baseName = normalizeTypeName(getTypeName(type));
if (baseName != null) {
fullNameBuilder.append(baseName);
ContainerUtil.addAll(
suggestions,
getSuggestionsByName(fullNameBuilder.toString(), variableKind, false, correctKeywords));
}
}
public static String getUnescapedText(
PsiFile file,
@Nullable final PsiElement startElement,
@Nullable final PsiElement endElement) {
final InjectedLanguageManager manager = InjectedLanguageManager.getInstance(file.getProject());
if (manager.getInjectionHost(file) == null) {
return file.getText()
.substring(
startElement == null ? 0 : startElement.getTextRange().getStartOffset(),
endElement == null
? file.getTextLength()
: endElement.getTextRange().getStartOffset());
}
final StringBuilder sb = new StringBuilder();
file.accept(
new PsiRecursiveElementWalkingVisitor() {
Boolean myState = startElement == null ? Boolean.TRUE : null;
@Override
public void visitElement(PsiElement element) {
if (element == startElement) myState = Boolean.TRUE;
if (element == endElement) myState = Boolean.FALSE;
if (Boolean.FALSE == myState) return;
if (Boolean.TRUE == myState && element.getFirstChild() == null) {
sb.append(getUnescapedLeafText(element, false));
} else {
super.visitElement(element);
}
}
});
return sb.toString();
}
private static String constantValueToConstantName(final String[] names) {
final StringBuilder result = new StringBuilder();
for (int i = 0; i < names.length; i++) {
if (i > 0) result.append("_");
result.append(names[i]);
}
return result.toString();
}
private static void generateParametersForDelegateCall(
GrChangeInfoImpl grInfo, GrMethod method, StringBuilder buffer) {
buffer.append("(");
final GrParameter[] oldParameters = method.getParameterList().getParameters();
final JavaParameterInfo[] parameters = grInfo.getNewParameters();
String[] params = new String[parameters.length];
for (int i = 0; i < parameters.length; i++) {
JavaParameterInfo parameter = parameters[i];
final int oldIndex = parameter.getOldIndex();
if (oldIndex >= 0) {
params[i] = oldParameters[oldIndex].getName();
} else {
params[i] = parameter.getDefaultValue();
}
}
buffer.append(StringUtil.join(params, ","));
buffer.append(");");
}
private static boolean generateDelegate(GrChangeInfoImpl grInfo) {
final GrMethod method = grInfo.getMethod();
final PsiClass psiClass = method.getContainingClass();
GrMethod newMethod = (GrMethod) method.copy();
newMethod = (GrMethod) psiClass.addAfter(newMethod, method);
StringBuilder buffer = new StringBuilder();
buffer.append("\n");
if (method.isConstructor()) {
buffer.append("this");
} else {
if (!PsiType.VOID.equals(method.getReturnType())) {
buffer.append("return ");
}
buffer.append(
GrChangeSignatureUtil.getNameWithQuotesIfNeeded(
grInfo.getNewName(), method.getProject()));
}
generateParametersForDelegateCall(grInfo, method, buffer);
final GrCodeBlock codeBlock =
GroovyPsiElementFactory.getInstance(method.getProject())
.createMethodBodyFromText(buffer.toString());
newMethod.setBlock(codeBlock);
newMethod.getModifierList().setModifierProperty(PsiModifier.ABSTRACT, false);
CodeStyleManager.getInstance(method.getProject()).reformat(newMethod);
return processPrimaryMethodInner(grInfo, method, null);
}
@Override
public String propertyNameToVariableName(String propertyName, VariableKind variableKind) {
if (variableKind == VariableKind.STATIC_FINAL_FIELD) {
String[] words = NameUtil.nameToWords(propertyName);
StringBuilder buffer = new StringBuilder();
for (int i = 0; i < words.length; i++) {
String word = words[i];
if (i > 0) {
buffer.append("_");
}
buffer.append(StringUtil.toUpperCase(word));
}
return buffer.toString();
}
String prefix = getPrefixByVariableKind(variableKind);
String name = propertyName;
if (!name.isEmpty() && !prefix.isEmpty() && !StringUtil.endsWithChar(prefix, '_')) {
name = Character.toUpperCase(name.charAt(0)) + name.substring(1);
}
name = prefix + name + getSuffixByVariableKind(variableKind);
name = changeIfNotIdentifier(name);
return name;
}
@Override
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
final PsiForeachStatement foreachStatement =
PsiTreeUtil.getParentOfType(descriptor.getPsiElement(), PsiForeachStatement.class);
if (foreachStatement != null) {
if (!FileModificationService.getInstance().preparePsiElementForWrite(foreachStatement))
return;
final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project);
PsiStatement body = foreachStatement.getBody();
final PsiExpression iteratedValue = foreachStatement.getIteratedValue();
if (body != null && iteratedValue != null) {
final PsiParameter parameter = foreachStatement.getIterationParameter();
final PsiIfStatement ifStatement = extractIfStatement(body);
final PsiMethodCallExpression methodCallExpression = extractAddCall(body, ifStatement);
if (methodCallExpression == null) return;
if (isAddAllCall(foreachStatement, body)) {
restoreComments(foreachStatement, body);
final PsiExpression qualifierExpression =
methodCallExpression.getMethodExpression().getQualifierExpression();
final String qualifierText =
qualifierExpression != null ? qualifierExpression.getText() : "";
final String callText =
StringUtil.getQualifiedName(
qualifierText, "addAll(" + getIteratedValueText(iteratedValue) + ");");
PsiElement result =
foreachStatement.replace(
elementFactory.createStatementFromText(callText, foreachStatement));
reformatWhenNeeded(project, result);
return;
}
final StringBuilder builder =
new StringBuilder(getIteratedValueText(iteratedValue) + ".stream()");
builder.append(createFiltersChainText(body, parameter, ifStatement));
builder.append(
createMapperFunctionalExpressionText(
parameter, methodCallExpression.getArgumentList().getExpressions()[0]));
builder.append(".collect(java.util.stream.Collectors.");
PsiElement result = null;
try {
final PsiExpression qualifierExpression =
methodCallExpression.getMethodExpression().getQualifierExpression();
if (qualifierExpression instanceof PsiReferenceExpression) {
final PsiElement resolve = ((PsiReferenceExpression) qualifierExpression).resolve();
if (resolve instanceof PsiVariable) {
if (resolve instanceof PsiLocalVariable
&& foreachStatement.equals(
PsiTreeUtil.skipSiblingsForward(
resolve.getParent(), PsiWhiteSpace.class))) {
final PsiExpression initializer = ((PsiVariable) resolve).getInitializer();
if (initializer instanceof PsiNewExpression) {
final PsiExpressionList argumentList =
((PsiNewExpression) initializer).getArgumentList();
if (argumentList != null && argumentList.getExpressions().length == 0) {
restoreComments(foreachStatement, body);
final String callText =
builder.toString()
+ createInitializerReplacementText(
((PsiVariable) resolve).getType(), initializer)
+ ")";
result =
initializer.replace(
elementFactory.createExpressionFromText(callText, null));
simplifyRedundantCast(result);
foreachStatement.delete();
return;
}
}
}
}
}
restoreComments(foreachStatement, body);
final String qualifierText =
qualifierExpression != null ? qualifierExpression.getText() : "";
final String callText =
StringUtil.getQualifiedName(
qualifierText, "addAll(" + builder.toString() + "toList()));");
result =
foreachStatement.replace(
elementFactory.createStatementFromText(callText, foreachStatement));
simplifyRedundantCast(result);
} finally {
reformatWhenNeeded(project, result);
}
}
}
}
@Override
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
final PsiForeachStatement foreachStatement =
PsiTreeUtil.getParentOfType(descriptor.getPsiElement(), PsiForeachStatement.class);
if (foreachStatement != null) {
if (!FileModificationService.getInstance().preparePsiElementForWrite(foreachStatement))
return;
PsiStatement body = foreachStatement.getBody();
final PsiExpression iteratedValue = foreachStatement.getIteratedValue();
if (body != null && iteratedValue != null) {
restoreComments(foreachStatement, body);
final PsiParameter parameter = foreachStatement.getIterationParameter();
final PsiIfStatement ifStmt = extractIfStatement(body);
StringBuilder buffer = new StringBuilder(getIteratedValueText(iteratedValue));
if (ifStmt != null) {
final PsiStatement thenBranch = ifStmt.getThenBranch();
LOG.assertTrue(thenBranch != null);
buffer.append(".stream()");
buffer.append(createFiltersChainText(body, parameter, ifStmt));
body = thenBranch;
}
buffer.append(".").append(getForEachMethodName()).append("(");
final String functionalExpressionText =
createForEachFunctionalExpressionText(project, body, parameter);
final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project);
PsiExpressionStatement callStatement =
(PsiExpressionStatement)
elementFactory.createStatementFromText(
buffer.toString() + functionalExpressionText + ");", foreachStatement);
callStatement = (PsiExpressionStatement) foreachStatement.replace(callStatement);
final PsiExpressionList argumentList =
((PsiCallExpression) callStatement.getExpression()).getArgumentList();
LOG.assertTrue(argumentList != null, callStatement.getText());
final PsiExpression[] expressions = argumentList.getExpressions();
LOG.assertTrue(expressions.length == 1);
if (expressions[0] instanceof PsiFunctionalExpression
&& ((PsiFunctionalExpression) expressions[0]).getFunctionalInterfaceType() == null) {
callStatement =
(PsiExpressionStatement)
callStatement.replace(
elementFactory.createStatementFromText(
buffer.toString()
+ "("
+ parameter.getText()
+ ") -> "
+ wrapInBlock(body)
+ ");",
callStatement));
}
simplifyRedundantCast(callStatement);
CodeStyleManager.getInstance(project)
.reformat(
JavaCodeStyleManager.getInstance(project).shortenClassReferences(callStatement));
}
}
}
