private static PsiField createField(
PsiLocalVariable local, PsiType forcedType, String fieldName, boolean includeInitializer) {
@NonNls StringBuilder pattern = new StringBuilder();
pattern.append("private int ");
pattern.append(fieldName);
if (local.getInitializer() == null) {
includeInitializer = false;
}
if (includeInitializer) {
pattern.append("=0");
}
pattern.append(";");
final Project project = local.getProject();
PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory();
try {
PsiField field = factory.createFieldFromText(pattern.toString(), null);
field.getTypeElement().replace(factory.createTypeElement(forcedType));
if (includeInitializer) {
PsiExpression initializer =
RefactoringUtil.convertInitializerToNormalExpression(
local.getInitializer(), forcedType);
field.getInitializer().replace(initializer);
}
for (PsiAnnotation annotation : local.getModifierList().getAnnotations()) {
field.getModifierList().add(annotation.copy());
}
return field;
} catch (IncorrectOperationException e) {
LOG.error(e);
return null;
}
}
private static PsiMethodReferenceExpression createMethodReference(
PsiMethodReferenceExpression expression, PsiTypeElement typeElement) {
final PsiType type = typeElement.getType();
final PsiElementFactory elementFactory =
JavaPsiFacade.getElementFactory(expression.getProject());
final PsiMethodReferenceExpression copy = (PsiMethodReferenceExpression) expression.copy();
copy.getQualifierType()
.replace(elementFactory.createTypeElement(((PsiClassType) type).rawType()));
return copy;
}
@Override
protected void doFix(Project project, ProblemDescriptor descriptor) {
final PsiElement element = descriptor.getPsiElement();
if (!(element instanceof PsiTypeElement)) {
return;
}
final PsiTypeElement typeElement = (PsiTypeElement) element;
final PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory();
final PsiClassType type =
factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_RUNTIME_EXCEPTION);
final PsiTypeElement newTypeElement = factory.createTypeElement(type);
typeElement.replace(newTypeElement);
}
static PsiExpression createCastExpression(
PsiExpression originalExpression, Project project, PsiType type)
throws IncorrectOperationException {
// remove nested casts
PsiElement element = PsiUtil.deparenthesizeExpression(originalExpression);
PsiElementFactory factory =
JavaPsiFacade.getInstance(originalExpression.getProject()).getElementFactory();
PsiTypeCastExpression typeCast =
(PsiTypeCastExpression) factory.createExpressionFromText("(Type)value", null);
typeCast = (PsiTypeCastExpression) CodeStyleManager.getInstance(project).reformat(typeCast);
typeCast.getCastType().replace(factory.createTypeElement(type));
if (element instanceof PsiConditionalExpression) {
// we'd better cast one branch of ternary expression if we could
PsiConditionalExpression expression = (PsiConditionalExpression) element.copy();
PsiExpression thenE = expression.getThenExpression();
PsiExpression elseE = expression.getElseExpression();
PsiType thenType = thenE == null ? null : thenE.getType();
PsiType elseType = elseE == null ? null : elseE.getType();
if (elseType != null && thenType != null) {
boolean replaceThen = !TypeConversionUtil.isAssignable(type, thenType);
boolean replaceElse = !TypeConversionUtil.isAssignable(type, elseType);
if (replaceThen != replaceElse) {
if (replaceThen) {
typeCast.getOperand().replace(thenE);
thenE.replace(typeCast);
} else {
typeCast.getOperand().replace(elseE);
elseE.replace(typeCast);
}
return expression;
}
}
}
typeCast.getOperand().replace(element);
return typeCast;
}
private static void processPrimaryMethod(
JavaChangeInfo changeInfo, PsiMethod method, PsiMethod baseMethod, boolean isOriginal)
throws IncorrectOperationException {
PsiElementFactory factory = JavaPsiFacade.getInstance(method.getProject()).getElementFactory();
if (changeInfo.isVisibilityChanged()) {
PsiModifierList modifierList = method.getModifierList();
final String highestVisibility =
isOriginal
? changeInfo.getNewVisibility()
: VisibilityUtil.getHighestVisibility(
changeInfo.getNewVisibility(),
VisibilityUtil.getVisibilityModifier(modifierList));
VisibilityUtil.setVisibility(modifierList, highestVisibility);
}
if (changeInfo.isNameChanged()) {
String newName =
baseMethod == null
? changeInfo.getNewName()
: RefactoringUtil.suggestNewOverriderName(
method.getName(), baseMethod.getName(), changeInfo.getNewName());
if (newName != null && !newName.equals(method.getName())) {
final PsiIdentifier nameId = method.getNameIdentifier();
assert nameId != null;
nameId.replace(
JavaPsiFacade.getInstance(method.getProject())
.getElementFactory()
.createIdentifier(newName));
}
}
final PsiSubstitutor substitutor =
baseMethod == null
? PsiSubstitutor.EMPTY
: ChangeSignatureProcessor.calculateSubstitutor(method, baseMethod);
if (changeInfo.isReturnTypeChanged()) {
PsiType newTypeElement =
changeInfo
.getNewReturnType()
.getType(changeInfo.getMethod().getParameterList(), method.getManager());
final PsiType returnType = substitutor.substitute(newTypeElement);
// don't modify return type for non-Java overriders (EJB)
if (method.getName().equals(changeInfo.getNewName())) {
final PsiTypeElement typeElement = method.getReturnTypeElement();
if (typeElement != null) {
typeElement.replace(factory.createTypeElement(returnType));
}
}
}
PsiParameterList list = method.getParameterList();
PsiParameter[] parameters = list.getParameters();
final JavaParameterInfo[] parameterInfos = changeInfo.getNewParameters();
final int delta =
baseMethod != null
? baseMethod.getParameterList().getParametersCount()
- method.getParameterList().getParametersCount()
: 0;
PsiParameter[] newParms = new PsiParameter[Math.max(parameterInfos.length - delta, 0)];
final String[] oldParameterNames = changeInfo.getOldParameterNames();
final String[] oldParameterTypes = changeInfo.getOldParameterTypes();
for (int i = 0; i < newParms.length; i++) {
JavaParameterInfo info = parameterInfos[i];
int index = info.getOldIndex();
if (index >= 0) {
PsiParameter parameter = parameters[index];
newParms[i] = parameter;
String oldName = oldParameterNames[index];
if (!oldName.equals(info.getName()) && oldName.equals(parameter.getName())) {
PsiIdentifier newIdentifier = factory.createIdentifier(info.getName());
parameter.getNameIdentifier().replace(newIdentifier);
}
String oldType = oldParameterTypes[index];
if (!oldType.equals(info.getTypeText())) {
parameter.normalizeDeclaration();
PsiType newType =
substitutor.substitute(
info.createType(changeInfo.getMethod().getParameterList(), method.getManager()));
parameter.getTypeElement().replace(factory.createTypeElement(newType));
}
} else {
newParms[i] = createNewParameter(changeInfo, info, substitutor);
}
}
resolveParameterVsFieldsConflicts(newParms, method, list, changeInfo.toRemoveParm());
fixJavadocsForChangedMethod(method, changeInfo, newParms.length);
if (changeInfo.isExceptionSetOrOrderChanged()) {
final PsiClassType[] newExceptions = getPrimaryChangedExceptionInfo(changeInfo);
fixPrimaryThrowsLists(method, newExceptions);
}
}
