protected String doCalculateSignature(PsiMethod method) {
final StringBuilder buffer = new StringBuilder();
final PsiModifierList modifierList = method.getModifierList();
String modifiers = modifierList.getText();
final String oldModifier = VisibilityUtil.getVisibilityModifier(modifierList);
final String newModifier = getVisibility();
String newModifierStr = VisibilityUtil.getVisibilityString(newModifier);
if (!newModifier.equals(oldModifier)) {
int index = modifiers.indexOf(oldModifier);
if (index >= 0) {
final StringBuilder buf = new StringBuilder(modifiers);
buf.replace(
index,
index + oldModifier.length() + ("".equals(newModifierStr) ? 1 : 0),
newModifierStr);
modifiers = buf.toString();
} else {
if (!StringUtil.isEmpty(newModifierStr)) {
newModifierStr += " ";
}
modifiers = newModifierStr + modifiers;
}
}
buffer.append(modifiers);
if (modifiers.length() > 0
&& !StringUtil.endsWithChar(modifiers, '\n')
&& !StringUtil.endsWithChar(modifiers, '\r')
&& !StringUtil.endsWithChar(modifiers, ' ')) {
buffer.append(" ");
}
if (!method.isConstructor()) {
final CanonicalTypes.Type type = getReturnType();
if (type != null) {
buffer.append(type.getTypeText());
}
buffer.append(" ");
}
buffer.append(getMethodName());
buffer.append("(");
final int lineBreakIdx = buffer.lastIndexOf("\n");
String indent =
StringUtil.repeatSymbol(
' ', lineBreakIdx >= 0 ? buffer.length() - lineBreakIdx - 1 : buffer.length());
List<ParameterTableModelItemBase<ParameterInfoImpl>> items = myParametersTableModel.getItems();
int curIndent = indent.length();
for (int i = 0; i < items.size(); i++) {
final ParameterTableModelItemBase<ParameterInfoImpl> item = items.get(i);
if (i > 0) {
buffer.append(",");
buffer.append("\n");
buffer.append(indent);
}
final String text = item.typeCodeFragment.getText();
buffer.append(text).append(" ");
final String name = item.parameter.getName();
buffer.append(name);
curIndent = indent.length() + text.length() + 1 + name.length();
}
// if (!items.isEmpty()) {
// buffer.append("\n");
// }
buffer.append(")");
PsiTypeCodeFragment[] thrownExceptionsFragments = myExceptionsModel.getTypeCodeFragments();
if (thrownExceptionsFragments.length > 0) {
// buffer.append("\n");
buffer.append(" throws ");
curIndent += 9; // ") throws ".length()
indent = StringUtil.repeatSymbol(' ', curIndent);
for (int i = 0; i < thrownExceptionsFragments.length; i++) {
String text = thrownExceptionsFragments[i].getText();
if (i != 0) buffer.append(indent);
buffer.append(text);
if (i < thrownExceptionsFragments.length - 1) {
buffer.append(",");
}
buffer.append("\n");
}
}
return buffer.toString();
}
@Override
protected String validateAndCommitData() {
PsiManager manager = PsiManager.getInstance(myProject);
PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory();
String name = getMethodName();
if (!JavaPsiFacade.getInstance(manager.getProject()).getNameHelper().isIdentifier(name)) {
return RefactoringMessageUtil.getIncorrectIdentifierMessage(name);
}
if (myMethod.canChangeReturnType() == MethodDescriptor.ReadWriteOption.ReadWrite) {
try {
((PsiTypeCodeFragment) myReturnTypeCodeFragment).getType();
} catch (PsiTypeCodeFragment.TypeSyntaxException e) {
myReturnTypeField.requestFocus();
return RefactoringBundle.message(
"changeSignature.wrong.return.type", myReturnTypeCodeFragment.getText());
} catch (PsiTypeCodeFragment.NoTypeException e) {
myReturnTypeField.requestFocus();
return RefactoringBundle.message("changeSignature.no.return.type");
}
}
List<ParameterTableModelItemBase<ParameterInfoImpl>> parameterInfos =
myParametersTableModel.getItems();
final int newParametersNumber = parameterInfos.size();
for (int i = 0; i < newParametersNumber; i++) {
final ParameterTableModelItemBase<ParameterInfoImpl> item = parameterInfos.get(i);
if (!JavaPsiFacade.getInstance(manager.getProject())
.getNameHelper()
.isIdentifier(item.parameter.getName())) {
return RefactoringMessageUtil.getIncorrectIdentifierMessage(item.parameter.getName());
}
final PsiType type;
try {
type = ((PsiTypeCodeFragment) parameterInfos.get(i).typeCodeFragment).getType();
} catch (PsiTypeCodeFragment.TypeSyntaxException e) {
return RefactoringBundle.message(
"changeSignature.wrong.type.for.parameter",
item.typeCodeFragment.getText(),
item.parameter.getName());
} catch (PsiTypeCodeFragment.NoTypeException e) {
return RefactoringBundle.message(
"changeSignature.no.type.for.parameter", item.parameter.getName());
}
item.parameter.setType(type);
if (type instanceof PsiEllipsisType && i != newParametersNumber - 1) {
return RefactoringBundle.message("changeSignature.vararg.not.last");
}
if (item.parameter.oldParameterIndex < 0) {
item.parameter.defaultValue =
ApplicationManager.getApplication()
.runWriteAction(
new Computable<String>() {
@Override
public String compute() {
return JavaCodeStyleManager.getInstance(myProject)
.qualifyClassReferences(item.defaultValueCodeFragment)
.getText();
}
});
String def = item.parameter.defaultValue;
def = def.trim();
if (!(type instanceof PsiEllipsisType)) {
try {
if (!StringUtil.isEmpty(def)) {
factory.createExpressionFromText(def, null);
}
} catch (IncorrectOperationException e) {
return e.getMessage();
}
}
}
}
ThrownExceptionInfo[] exceptionInfos = myExceptionsModel.getThrownExceptions();
PsiTypeCodeFragment[] typeCodeFragments = myExceptionsModel.getTypeCodeFragments();
for (int i = 0; i < exceptionInfos.length; i++) {
ThrownExceptionInfo exceptionInfo = exceptionInfos[i];
PsiTypeCodeFragment typeCodeFragment = typeCodeFragments[i];
try {
PsiType type = typeCodeFragment.getType();
if (!(type instanceof PsiClassType)) {
return RefactoringBundle.message(
"changeSignature.wrong.type.for.exception", typeCodeFragment.getText());
}
PsiClassType throwable =
JavaPsiFacade.getInstance(myProject)
.getElementFactory()
.createTypeByFQClassName("java.lang.Throwable", type.getResolveScope());
if (!throwable.isAssignableFrom(type)) {
return RefactoringBundle.message(
"changeSignature.not.throwable.type", typeCodeFragment.getText());
}
exceptionInfo.setType((PsiClassType) type);
} catch (PsiTypeCodeFragment.TypeSyntaxException e) {
return RefactoringBundle.message(
"changeSignature.wrong.type.for.exception", typeCodeFragment.getText());
} catch (PsiTypeCodeFragment.NoTypeException e) {
return RefactoringBundle.message("changeSignature.no.type.for.exception");
}
}
// warnings
try {
if (myMethod.canChangeReturnType() == MethodDescriptor.ReadWriteOption.ReadWrite) {
if (!RefactoringUtil.isResolvableType(
((PsiTypeCodeFragment) myReturnTypeCodeFragment).getType())) {
if (Messages.showOkCancelDialog(
myProject,
RefactoringBundle.message(
"changeSignature.cannot.resolve.return.type",
myReturnTypeCodeFragment.getText()),
RefactoringBundle.message("changeSignature.refactoring.name"),
Messages.getWarningIcon())
!= 0) {
return EXIT_SILENTLY;
}
}
}
for (ParameterTableModelItemBase<ParameterInfoImpl> item : parameterInfos) {
if (!RefactoringUtil.isResolvableType(
((PsiTypeCodeFragment) item.typeCodeFragment).getType())) {
if (Messages.showOkCancelDialog(
myProject,
RefactoringBundle.message(
"changeSignature.cannot.resolve.parameter.type",
item.typeCodeFragment.getText(),
item.parameter.getName()),
RefactoringBundle.message("changeSignature.refactoring.name"),
Messages.getWarningIcon())
!= 0) {
return EXIT_SILENTLY;
}
}
}
} catch (PsiTypeCodeFragment.IncorrectTypeException ignored) {
}
return null;
}
