diff --git a/java/structuralsearch-java/src/com/intellij/structuralsearch/JavaReplaceHandler.java b/java/structuralsearch-java/src/com/intellij/structuralsearch/JavaReplaceHandler.java index 216610b7434c..d3cd64dfa6d4 100644 --- a/java/structuralsearch-java/src/com/intellij/structuralsearch/JavaReplaceHandler.java +++ b/java/structuralsearch-java/src/com/intellij/structuralsearch/JavaReplaceHandler.java @@ -174,8 +174,7 @@ public class JavaReplaceHandler extends StructuralReplaceHandler { } if (comment != null && replacementNamedElement instanceof PsiDocCommentOwner && - !(replacementNamedElement.getFirstChild() instanceof PsiDocComment) - ) { + !(replacementNamedElement.getFirstChild() instanceof PsiDocComment)) { final PsiElement nextSibling = comment.getNextSibling(); PsiElement prevSibling = comment.getPrevSibling(); replacementNamedElement.addRangeBefore( @@ -186,48 +185,50 @@ public class JavaReplaceHandler extends StructuralReplaceHandler { } if (originalNamedElement instanceof PsiModifierListOwner && - replacementNamedElement instanceof PsiModifierListOwner - ) { - PsiModifierList modifierList = ((PsiModifierListOwner)originalNamedElements.get(name)).getModifierList(); - - if (searchedNamedElement instanceof PsiModifierListOwner) { - PsiModifierList modifierListOfSearchedElement = ((PsiModifierListOwner)searchedNamedElement).getModifierList(); - final PsiModifierListOwner modifierListOwner = ((PsiModifierListOwner)replacementNamedElement); - PsiModifierList modifierListOfReplacement = modifierListOwner.getModifierList(); - - if (modifierListOfSearchedElement.getTextLength() == 0 && - modifierListOfReplacement.getTextLength() == 0 && - modifierList.getTextLength() > 0) { - modifierListOfReplacement.replace(modifierList); - } else if (modifierListOfSearchedElement.getTextLength() == 0 && modifierList.getTextLength() > 0) { - final PsiModifierList copy = (PsiModifierList)modifierList.copy(); - for (String modifier : PsiModifier.MODIFIERS) { - if (modifierListOfReplacement.hasExplicitModifier(modifier)) { - copy.setModifierProperty(modifier, true); - } - } - final PsiElement anchor = copy.getFirstChild(); - for (PsiAnnotation annotation : modifierListOfReplacement.getAnnotations()) { - copy.addBefore(annotation, anchor); - } - modifierListOfReplacement.replace(copy); - } - } + searchedNamedElement instanceof PsiModifierListOwner && + replacementNamedElement instanceof PsiModifierListOwner) { + copyModifiersAndAnnotations((PsiModifierListOwner)originalNamedElement, + (PsiModifierListOwner)searchedNamedElement, + (PsiModifierListOwner)replacementNamedElement); } if (originalNamedElement instanceof PsiMethod && searchedNamedElement instanceof PsiMethod && replacementNamedElement instanceof PsiMethod) { - final PsiMethod searchedMethod = (PsiMethod)searchedNamedElement; - final PsiMethod replacementMethod = (PsiMethod)replacementNamedElement; - if (searchedMethod.getBody() == null && replacementMethod.getBody() == null) { - final PsiMethod originalMethod = (PsiMethod)originalNamedElement; - final PsiCodeBlock originalBody = originalMethod.getBody(); - if (originalBody != null) { - replacementMethod.add(originalBody); - } + copyMethodBodyIfNotReplaced((PsiMethod)originalNamedElement, (PsiMethod)searchedNamedElement, (PsiMethod)replacementNamedElement); + } + } + } + + private static void copyMethodBodyIfNotReplaced(PsiMethod original, PsiMethod query, PsiMethod replacement) { + final PsiCodeBlock originalBody = original.getBody(); + if (originalBody != null && query.getBody() == null && replacement.getBody() == null) { + replacement.add(originalBody); + } + } + + private static void copyModifiersAndAnnotations(PsiModifierListOwner original, + PsiModifierListOwner query, + PsiModifierListOwner replacement) { + final PsiModifierList originalModifierList = original.getModifierList(); + final PsiModifierList queryModifierList = query.getModifierList(); + final PsiModifierList replacementModifierList = replacement.getModifierList(); + + if (originalModifierList == null || queryModifierList == null || replacementModifierList == null) { + return; + } + if (originalModifierList.getTextLength() != 0 && queryModifierList.getTextLength() == 0) { + final PsiModifierList copy = (PsiModifierList)originalModifierList.copy(); + for (String modifier : PsiModifier.MODIFIERS) { + if (replacementModifierList.hasExplicitModifier(modifier)) { + copy.setModifierProperty(modifier, true); } } + final PsiElement anchor = copy.getFirstChild(); + for (PsiAnnotation annotation : replacementModifierList.getAnnotations()) { + copy.addBefore(annotation, anchor); + } + replacementModifierList.replace(copy); } } @@ -242,6 +243,7 @@ public class JavaReplaceHandler extends StructuralReplaceHandler { return replacement; } + @Override public void replace(final ReplacementInfo info, ReplaceOptions options) { PsiElement elementToReplace = info.getMatch(0); if (elementToReplace == null) { @@ -257,15 +259,15 @@ public class JavaReplaceHandler extends StructuralReplaceHandler { replacementToMake = "@" + replacementToMake; } - final PsiElement[] statements = ReplacerUtil + final PsiElement[] replacements = ReplacerUtil .createTreeForReplacement(replacementToMake, elementToReplace instanceof PsiMember && !isSymbolReplacement(elementToReplace) ? PatternTreeContext.Class : PatternTreeContext.Block, myContext); - if (elementToReplace instanceof PsiAnnotation && statements.length == 1) { - final PsiElement statement = statements[0]; - if (statement instanceof PsiDeclarationStatement) { - final PsiDeclarationStatement declarationStatement = (PsiDeclarationStatement)statement; + if (elementToReplace instanceof PsiAnnotation && replacements.length == 1) { + final PsiElement replacement = replacements[0]; + if (replacement instanceof PsiDeclarationStatement) { + final PsiDeclarationStatement declarationStatement = (PsiDeclarationStatement)replacement; final PsiElement firstChild = declarationStatement.getFirstChild(); if (firstChild instanceof PsiModifierList) { final PsiModifierList modifierList = (PsiModifierList)firstChild; @@ -278,12 +280,12 @@ public class JavaReplaceHandler extends StructuralReplaceHandler { return; } if (listContext) { - if (statements.length > 1) { - final PsiElement replacement = elementParent.addRangeBefore(statements[0], statements[statements.length - 1], elementToReplace); + if (replacements.length > 1) { + final PsiElement replacement = elementParent.addRangeBefore(replacements[0], replacements[replacements.length - 1], elementToReplace); copyUnmatchedElements(elementToReplace, replacement); } - else if (statements.length == 1) { - PsiElement replacement = getMatchExpr(statements[0], elementToReplace); + else if (replacements.length == 1) { + PsiElement replacement = getMatchExpr(replacements[0], elementToReplace); if (elementToReplace instanceof PsiParameter && replacement instanceof PsiLocalVariable) { final PsiVariable variable = (PsiVariable)replacement; final PsiIdentifier identifier = variable.getNameIdentifier(); @@ -337,8 +339,8 @@ public class JavaReplaceHandler extends StructuralReplaceHandler { } } } - else if (statements.length > 0) { - PsiElement replacement = ReplacerUtil.copySpacesAndCommentsBefore(elementToReplace, statements, replacementToMake, elementParent); + else if (replacements.length > 0) { + PsiElement replacement = ReplacerUtil.copySpacesAndCommentsBefore(elementToReplace, replacements, replacementToMake, elementParent); replacement = getMatchExpr(replacement, elementToReplace); @@ -366,42 +368,14 @@ public class JavaReplaceHandler extends StructuralReplaceHandler { final PsiStatement[] searchStatements = getCodeBlock().getStatements(); if (searchStatements.length > 0 && searchStatements[0] instanceof PsiDeclarationStatement && - ((PsiDeclarationStatement)searchStatements[0]).getDeclaredElements()[0] instanceof PsiClass - ) { + ((PsiDeclarationStatement)searchStatements[0]).getDeclaredElements()[0] instanceof PsiClass) { final PsiClass replaceClazz = (PsiClass)replacement; final PsiClass queryClazz = (PsiClass)((PsiDeclarationStatement)searchStatements[0]).getDeclaredElements()[0]; final PsiClass clazz = (PsiClass)elementToReplace; - if (replaceClazz.getExtendsList().getTextLength() == 0 && - queryClazz.getExtendsList().getTextLength() == 0 && - clazz.getExtendsList().getTextLength() != 0 - ) { - replaceClazz.addBefore(clazz.getExtendsList().getPrevSibling(), replaceClazz.getExtendsList()); // whitespace - replaceClazz.getExtendsList().addRange( - clazz.getExtendsList().getFirstChild(), clazz.getExtendsList().getLastChild() - ); - } - - if (replaceClazz.getImplementsList().getTextLength() == 0 && - queryClazz.getImplementsList().getTextLength() == 0 && - clazz.getImplementsList().getTextLength() != 0 - ) { - replaceClazz.addBefore(clazz.getImplementsList().getPrevSibling(), replaceClazz.getImplementsList()); // whitespace - replaceClazz.getImplementsList().addRange( - clazz.getImplementsList().getFirstChild(), - clazz.getImplementsList().getLastChild() - ); - } - - if (replaceClazz.getTypeParameterList().getTextLength() == 0 && - queryClazz.getTypeParameterList().getTextLength() == 0 && - clazz.getTypeParameterList().getTextLength() != 0 - ) { - // skip < and > - replaceClazz.getTypeParameterList().replace( - clazz.getTypeParameterList() - ); - } + copyExtendsListIfNotReplaced(clazz, queryClazz, replaceClazz); + copyImplementsListIfNotReplaced(clazz, queryClazz, replaceClazz); + copyTypeParameterListIfNotReplaced(clazz, queryClazz, replaceClazz); } } @@ -460,6 +434,41 @@ public class JavaReplaceHandler extends StructuralReplaceHandler { } } + private static void copyTypeParameterListIfNotReplaced(PsiClass original, PsiClass query, PsiClass replacement) { + final PsiTypeParameterList originalTypeParameterList = original.getTypeParameterList(); + final PsiTypeParameterList queryTypeParameterList = query.getTypeParameterList(); + final PsiTypeParameterList replacementTypeParameterList = replacement.getTypeParameterList(); + if (originalTypeParameterList == null || queryTypeParameterList == null || replacementTypeParameterList == null) { + return; + } + if (originalTypeParameterList.getTypeParameters().length != 0 && + queryTypeParameterList.getTypeParameters().length == 0 && + replacementTypeParameterList.getTypeParameters().length == 0) { + replacementTypeParameterList.replace(originalTypeParameterList); + } + } + + private static void copyImplementsListIfNotReplaced(PsiClass original, PsiClass query, PsiClass replacement) { + copyReferenceListIfNotReplaced(original.getImplementsList(), query.getImplementsList(), replacement.getImplementsList()); + } + + private static void copyExtendsListIfNotReplaced(PsiClass original, PsiClass query, PsiClass replacement) { + copyReferenceListIfNotReplaced(original.getExtendsList(), query.getExtendsList(), replacement.getExtendsList()); + } + + private static void copyReferenceListIfNotReplaced(PsiReferenceList originalReferenceList, + PsiReferenceList queryReferenceList, + PsiReferenceList replacementReferenceList) { + if (originalReferenceList == null || queryReferenceList == null || replacementReferenceList == null) { + return; + } + if (originalReferenceList.getReferenceElements().length != 0 && + queryReferenceList.getReferenceElements().length == 0 && + replacementReferenceList.getReferenceElements().length == 0) { + replacementReferenceList.replace(originalReferenceList); + } + } + private static void addElementAfterAnchor(PsiElement parentElement, PsiElement element, PsiElement anchor) { parentElement.addAfter(element, anchor); final PsiElement sibling = element.getPrevSibling();