@Override
protected boolean preprocessUsages(@NotNull final Ref<UsageInfo[]> refUsages) {
final MultiMap<PsiElement, String> conflicts = new MultiMap<PsiElement, String>();
myExtractEnumProcessor.findEnumConstantConflicts(refUsages);
if (!DestinationFolderComboBox.isAccessible(
myProject,
sourceClass.getContainingFile().getVirtualFile(),
myClass.getContainingFile().getContainingDirectory().getVirtualFile())) {
conflicts.putValue(
sourceClass,
"Extracted class won't be accessible in "
+ RefactoringUIUtil.getDescription(sourceClass, true));
}
ApplicationManager.getApplication()
.runWriteAction(
new Runnable() {
public void run() {
myClass.delete();
}
});
final Project project = sourceClass.getProject();
final GlobalSearchScope scope = GlobalSearchScope.allScope(project);
final PsiClass existingClass =
JavaPsiFacade.getInstance(project).findClass(getQualifiedName(), scope);
if (existingClass != null) {
conflicts.putValue(
existingClass,
RefactorJBundle.message("cannot.perform.the.refactoring")
+ RefactorJBundle.message("there.already.exists.a.class.with.the.chosen.name"));
}
if (!myGenerateAccessors) {
calculateInitializersConflicts(conflicts);
final NecessaryAccessorsVisitor visitor = checkNecessaryGettersSetters4ExtractedClass();
final NecessaryAccessorsVisitor srcVisitor = checkNecessaryGettersSetters4SourceClass();
final Set<PsiField> fieldsNeedingGetter = new LinkedHashSet<PsiField>();
fieldsNeedingGetter.addAll(visitor.getFieldsNeedingGetter());
fieldsNeedingGetter.addAll(srcVisitor.getFieldsNeedingGetter());
for (PsiField field : fieldsNeedingGetter) {
conflicts.putValue(field, "Field \'" + field.getName() + "\' needs getter");
}
final Set<PsiField> fieldsNeedingSetter = new LinkedHashSet<PsiField>();
fieldsNeedingSetter.addAll(visitor.getFieldsNeedingSetter());
fieldsNeedingSetter.addAll(srcVisitor.getFieldsNeedingSetter());
for (PsiField field : fieldsNeedingSetter) {
conflicts.putValue(field, "Field \'" + field.getName() + "\' needs setter");
}
}
checkConflicts(refUsages, conflicts);
return showConflicts(conflicts, refUsages.get());
}
public static boolean isClassEquivalentTo(@NotNull PsiClass aClass, PsiElement another) {
if (aClass == another) return true;
if (!(another instanceof PsiClass)) return false;
String name1 = aClass.getName();
if (name1 == null) return false;
if (!another.isValid()) return false;
String name2 = ((PsiClass) another).getName();
if (name2 == null) return false;
if (name1.hashCode() != name2.hashCode()) return false;
if (!name1.equals(name2)) return false;
String qName1 = aClass.getQualifiedName();
String qName2 = ((PsiClass) another).getQualifiedName();
if (qName1 == null || qName2 == null) {
//noinspection StringEquality
if (qName1 != qName2) return false;
if (aClass instanceof PsiTypeParameter && another instanceof PsiTypeParameter) {
PsiTypeParameter p1 = (PsiTypeParameter) aClass;
PsiTypeParameter p2 = (PsiTypeParameter) another;
return p1.getIndex() == p2.getIndex()
&& aClass.getManager().areElementsEquivalent(p1.getOwner(), p2.getOwner());
} else {
return false;
}
}
if (qName1.hashCode() != qName2.hashCode() || !qName1.equals(qName2)) {
return false;
}
if (originalElement(aClass).equals(originalElement((PsiClass) another))) {
return true;
}
final PsiFile file1 = aClass.getContainingFile().getOriginalFile();
final PsiFile file2 = another.getContainingFile().getOriginalFile();
// see com.intellij.openapi.vcs.changes.PsiChangeTracker
// see com.intellij.psi.impl.PsiFileFactoryImpl#createFileFromText(CharSequence,PsiFile)
final PsiFile original1 = file1.getUserData(PsiFileFactory.ORIGINAL_FILE);
final PsiFile original2 = file2.getUserData(PsiFileFactory.ORIGINAL_FILE);
if (original1 == original2 && original1 != null
|| original1 == file2
|| original2 == file1
|| file1 == file2) {
return compareClassSeqNumber(aClass, (PsiClass) another);
}
final FileIndexFacade fileIndex =
ServiceManager.getService(file1.getProject(), FileIndexFacade.class);
final VirtualFile vfile1 = file1.getViewProvider().getVirtualFile();
final VirtualFile vfile2 = file2.getViewProvider().getVirtualFile();
boolean lib1 = fileIndex.isInLibraryClasses(vfile1);
boolean lib2 = fileIndex.isInLibraryClasses(vfile2);
return (fileIndex.isInSource(vfile1) || lib1) && (fileIndex.isInSource(vfile2) || lib2);
}
private static void findClassUsages(
final PsiClass psiClass,
final PsiElement[] allElementsToDelete,
final List<UsageInfo> usages) {
final boolean justPrivates = containsOnlyPrivates(psiClass);
final String qualifiedName = psiClass.getQualifiedName();
final boolean annotationType = psiClass.isAnnotationType() && qualifiedName != null;
ReferencesSearch.search(psiClass)
.forEach(
reference -> {
final PsiElement element = reference.getElement();
if (!isInside(element, allElementsToDelete)) {
PsiElement parent = element.getParent();
if (parent instanceof PsiReferenceList) {
final PsiElement pparent = parent.getParent();
if (pparent instanceof PsiClass
&& element instanceof PsiJavaCodeReferenceElement) {
final PsiClass inheritor = (PsiClass) pparent;
// If psiClass contains only private members, then it is safe to remove it and
// change inheritor's extends/implements accordingly
if (justPrivates) {
if (parent.equals(inheritor.getExtendsList())
|| parent.equals(inheritor.getImplementsList())) {
usages.add(
new SafeDeleteExtendsClassUsageInfo(
(PsiJavaCodeReferenceElement) element, psiClass, inheritor));
return true;
}
}
}
}
LOG.assertTrue(element.getTextRange() != null);
final PsiFile containingFile = psiClass.getContainingFile();
boolean sameFileWithSingleClass = false;
if (containingFile instanceof PsiClassOwner) {
final PsiClass[] classes = ((PsiClassOwner) containingFile).getClasses();
sameFileWithSingleClass =
classes.length == 1
&& classes[0] == psiClass
&& element.getContainingFile() == containingFile;
}
final boolean safeDelete = sameFileWithSingleClass || isInNonStaticImport(element);
if (annotationType && parent instanceof PsiAnnotation) {
usages.add(
new SafeDeleteAnnotation((PsiAnnotation) parent, psiClass, safeDelete));
} else {
usages.add(
new SafeDeleteReferenceJavaDeleteUsageInfo(element, psiClass, safeDelete));
}
}
return true;
});
}
@NotNull
public static SearchScope getClassUseScope(@NotNull PsiClass aClass) {
if (aClass instanceof PsiAnonymousClass) {
return new LocalSearchScope(aClass);
}
final GlobalSearchScope maximalUseScope = ResolveScopeManager.getElementUseScope(aClass);
PsiFile file = aClass.getContainingFile();
if (PsiImplUtil.isInServerPage(file)) return maximalUseScope;
final PsiClass containingClass = aClass.getContainingClass();
if (aClass.hasModifierProperty(PsiModifier.PUBLIC)
|| aClass.hasModifierProperty(PsiModifier.PROTECTED)) {
return containingClass == null ? maximalUseScope : containingClass.getUseScope();
} else if (aClass.hasModifierProperty(PsiModifier.PRIVATE)
|| aClass instanceof PsiTypeParameter) {
PsiClass topClass = PsiUtil.getTopLevelClass(aClass);
return new LocalSearchScope(topClass == null ? aClass.getContainingFile() : topClass);
} else {
PsiPackage aPackage = null;
if (file instanceof PsiJavaFile) {
aPackage =
JavaPsiFacade.getInstance(aClass.getProject())
.findPackage(((PsiJavaFile) file).getPackageName());
}
if (aPackage == null) {
PsiDirectory dir = file.getContainingDirectory();
if (dir != null) {
aPackage = JavaDirectoryService.getInstance().getPackage(dir);
}
}
if (aPackage != null) {
SearchScope scope = PackageScope.packageScope(aPackage, false);
scope = scope.intersectWith(maximalUseScope);
return scope;
}
return new LocalSearchScope(file);
}
}
private static void addIdAndSuperClasses(PsiFile file, @NotNull TIntHashSet forward) {
if (file instanceof PsiJavaFile
&& file.getName().equals("Object.class")
&& ((PsiJavaFile) file).getPackageName().equals("java.lang")) {
return;
}
VirtualFile virtualFile = PsiUtilCore.getVirtualFile(file);
if (virtualFile instanceof VirtualFileWithId
&& forward.add(getAbsId(virtualFile))
&& file instanceof PsiClassOwner) {
for (PsiClass aClass : ((PsiClassOwner) file).getClasses()) {
for (PsiClass superClass : aClass.getSupers()) {
addIdAndSuperClasses(superClass.getContainingFile(), forward);
}
}
}
}
@Nullable
protected VirtualFile findCoreJar(@Nullable Module module) {
if (module == null) return null;
JavaPsiFacade javaFacade = JavaPsiFacade.getInstance(module.getProject());
for (PsiClass aClass :
javaFacade.findClasses(
getSomeFrameworkClass(), GlobalSearchScope.moduleWithLibrariesScope(module))) {
VirtualFile virtualFile = aClass.getContainingFile().getVirtualFile();
if (virtualFile != null && virtualFile.getFileSystem() instanceof JarFileSystem) {
VirtualFile localFile = PathUtil.getLocalFile(virtualFile);
if (isCoreJar(localFile)) {
return localFile;
}
}
}
return null;
}
private void processMethodsDuplicates() {
ProgressManager.getInstance()
.runProcessWithProgressSynchronously(
() ->
ApplicationManager.getApplication()
.runReadAction(
() -> {
if (!myTargetSuperClass.isValid()) return;
final Query<PsiClass> search =
ClassInheritorsSearch.search(myTargetSuperClass);
final Set<VirtualFile> hierarchyFiles = new HashSet<>();
for (PsiClass aClass : search) {
final PsiFile containingFile = aClass.getContainingFile();
if (containingFile != null) {
final VirtualFile virtualFile = containingFile.getVirtualFile();
if (virtualFile != null) {
hierarchyFiles.add(virtualFile);
}
}
}
final Set<PsiMember> methodsToSearchDuplicates = new HashSet<>();
for (PsiMember psiMember : myMembersAfterMove) {
if (psiMember instanceof PsiMethod
&& psiMember.isValid()
&& ((PsiMethod) psiMember).getBody() != null) {
methodsToSearchDuplicates.add(psiMember);
}
}
MethodDuplicatesHandler.invokeOnScope(
myProject,
methodsToSearchDuplicates,
new AnalysisScope(myProject, hierarchyFiles),
true);
}),
MethodDuplicatesHandler.REFACTORING_NAME,
true,
myProject);
}
@NotNull
private Object[] getSubclassVariants(
@NotNull PsiPackage context, @NotNull String[] extendClasses) {
HashSet<Object> lookups = new HashSet<Object>();
GlobalSearchScope packageScope = PackageScope.packageScope(context, true);
GlobalSearchScope scope = myJavaClassReferenceSet.getProvider().getScope();
if (scope != null) {
packageScope = packageScope.intersectWith(scope);
}
final GlobalSearchScope allScope = ProjectScope.getAllScope(context.getProject());
final boolean instantiatable =
JavaClassReferenceProvider.INSTANTIATABLE.getBooleanValue(getOptions());
final boolean notInterface =
JavaClassReferenceProvider.NOT_INTERFACE.getBooleanValue(getOptions());
final boolean notEnum = JavaClassReferenceProvider.NOT_ENUM.getBooleanValue(getOptions());
final boolean concrete = JavaClassReferenceProvider.CONCRETE.getBooleanValue(getOptions());
final ClassKind classKind = getClassKind();
for (String extendClassName : extendClasses) {
final PsiClass extendClass =
JavaPsiFacade.getInstance(context.getProject()).findClass(extendClassName, allScope);
if (extendClass != null) {
// add itself
if (packageScope.contains(extendClass.getContainingFile().getVirtualFile())) {
if (isClassAccepted(
extendClass, classKind, instantiatable, concrete, notInterface, notEnum)) {
ContainerUtil.addIfNotNull(createSubclassLookupValue(context, extendClass), lookups);
}
}
for (final PsiClass clazz : ClassInheritorsSearch.search(extendClass, packageScope, true)) {
if (isClassAccepted(clazz, classKind, instantiatable, concrete, notInterface, notEnum)) {
ContainerUtil.addIfNotNull(createSubclassLookupValue(context, clazz), lookups);
}
}
}
}
return lookups.toArray();
}
public static void addAvailableSystemScripts(
final Collection<String> result, @NotNull Module module) {
VirtualFile scriptRoot = null;
GlobalSearchScope searchScope =
GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module, false);
for (PsiClass aClass :
JavaPsiFacade.getInstance(module.getProject()).findClasses("CreateApp_", searchScope)) {
PsiClass superClass = aClass.getSuperClass();
if (superClass != null
&& GroovyCommonClassNames.GROOVY_LANG_SCRIPT.equals(superClass.getQualifiedName())) {
PsiFile psiFile = aClass.getContainingFile();
if (psiFile != null) {
VirtualFile file = psiFile.getVirtualFile();
if (file != null && file.getFileSystem() instanceof ArchiveFileSystem) {
VirtualFile parent = file.getParent();
if (parent != null && parent.findChild("Console.class") != null) {
scriptRoot = parent;
break;
}
}
}
}
}
if (scriptRoot == null) return;
Pattern scriptPattern = Pattern.compile("([A-Za-z0-9]+)_?\\.class");
for (VirtualFile file : scriptRoot.getChildren()) {
Matcher matcher = scriptPattern.matcher(file.getName());
if (matcher.matches()) {
result.add(GroovyNamesUtil.camelToSnake(matcher.group(1)));
}
}
}
static boolean isSideEffectFreeConstructor(PsiNewExpression newExpression) {
PsiJavaCodeReferenceElement classReference = newExpression.getClassReference();
PsiClass aClass = classReference == null ? null : (PsiClass) classReference.resolve();
String qualifiedName = aClass == null ? null : aClass.getQualifiedName();
if (qualifiedName == null) return false;
if (ourSideEffectFreeClasses.contains(qualifiedName)) return true;
PsiFile file = aClass.getContainingFile();
PsiDirectory directory = file.getContainingDirectory();
PsiPackage classPackage = JavaDirectoryService.getInstance().getPackage(directory);
String packageName = classPackage == null ? null : classPackage.getQualifiedName();
// all Throwable descendants from java.lang are side effects free
if ("java.lang".equals(packageName) || "java.io".equals(packageName)) {
PsiClass throwableClass =
JavaPsiFacade.getInstance(aClass.getProject())
.findClass("java.lang.Throwable", aClass.getResolveScope());
if (throwableClass != null
&& InheritanceUtil.isInheritorOrSelf(aClass, throwableClass, true)) {
return true;
}
}
return false;
}
@NotNull
private List<Pair<PsiClass, VirtualFile>> doFindClasses(
@NotNull String qName, @NotNull final GlobalSearchScope scope) {
final Collection<PsiClass> classes =
JavaFullClassNameIndex.getInstance().get(qName.hashCode(), myManager.getProject(), scope);
if (classes.isEmpty()) return Collections.emptyList();
List<Pair<PsiClass, VirtualFile>> result = new ArrayList<>(classes.size());
for (PsiClass aClass : classes) {
final String qualifiedName = aClass.getQualifiedName();
if (qualifiedName == null || !qualifiedName.equals(qName)) continue;
PsiFile file = aClass.getContainingFile();
if (file == null) {
throw new AssertionError("No file for class: " + aClass + " of " + aClass.getClass());
}
final boolean valid = file.isValid();
VirtualFile vFile = file.getVirtualFile();
if (!valid) {
LOG.error(
"Invalid file "
+ file
+ "; virtualFile:"
+ vFile
+ (vFile != null && !vFile.isValid() ? " (invalid)" : "")
+ "; id="
+ (vFile == null ? 0 : ((VirtualFileWithId) vFile).getId()),
new PsiInvalidElementAccessException(aClass));
continue;
}
if (!hasAcceptablePackage(vFile)) continue;
result.add(Pair.create(aClass, vFile));
}
return result;
}
private void doMoveMethod(PsiSubstitutor substitutor, MemberInfo info) {
PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(myProject);
PsiMethod method = (PsiMethod) info.getMember();
PsiMethod sibling = method;
PsiMethod anchor = null;
while (sibling != null) {
sibling = PsiTreeUtil.getNextSiblingOfType(sibling, PsiMethod.class);
if (sibling != null) {
anchor =
MethodSignatureUtil.findMethodInSuperClassBySignatureInDerived(
method.getContainingClass(),
myTargetSuperClass,
sibling.getSignature(PsiSubstitutor.EMPTY),
false);
if (anchor != null) {
break;
}
}
}
PsiMethod methodCopy = (PsiMethod) method.copy();
Language language = myTargetSuperClass.getLanguage();
final PsiMethod superClassMethod = myTargetSuperClass.findMethodBySignature(methodCopy, false);
if (superClassMethod != null && superClassMethod.findDeepestSuperMethods().length == 0
|| method.findSuperMethods(myTargetSuperClass).length == 0) {
deleteOverrideAnnotationIfFound(methodCopy);
}
boolean isOriginalMethodAbstract =
method.hasModifierProperty(PsiModifier.ABSTRACT)
|| method.hasModifierProperty(PsiModifier.DEFAULT);
boolean isOriginalMethodPrototype =
method instanceof HaxeFunctionPrototypeDeclarationWithAttributes;
if (myIsTargetInterface || info.isToAbstract()) {
ChangeContextUtil.clearContextInfo(method);
if (!info.isToAbstract()
&& !method.hasModifierProperty(PsiModifier.ABSTRACT)
&& PsiUtil.isLanguageLevel8OrHigher(myTargetSuperClass)) {
// pull as default
RefactoringUtil.makeMethodDefault(methodCopy);
isOriginalMethodAbstract = true;
} else {
RefactoringUtil.makeMethodAbstract(myTargetSuperClass, methodCopy);
}
RefactoringUtil.replaceMovedMemberTypeParameters(
methodCopy, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory);
myJavaDocPolicy.processCopiedJavaDoc(
methodCopy.getDocComment(), method.getDocComment(), isOriginalMethodAbstract);
final PsiMember movedElement;
if (superClassMethod != null && superClassMethod.hasModifierProperty(PsiModifier.ABSTRACT)) {
movedElement =
(PsiMember) superClassMethod.replace(convertMethodToLanguage(methodCopy, language));
} else {
methodCopy =
HaxeElementGenerator.createFunctionPrototypeDeclarationWithAttributes(
myProject, methodCopy.getText().trim() + ";");
movedElement =
anchor != null
? (PsiMember) myTargetSuperClass.addBefore(methodCopy, anchor)
: (PsiMember)
myTargetSuperClass.addBefore(methodCopy, myTargetSuperClass.getRBrace());
reformat(movedElement);
}
CodeStyleSettings styleSettings = CodeStyleSettingsManager.getSettings(method.getProject());
if (styleSettings.INSERT_OVERRIDE_ANNOTATION) {
if (PsiUtil.isLanguageLevel5OrHigher(mySourceClass) && !myIsTargetInterface
|| PsiUtil.isLanguageLevel6OrHigher(mySourceClass)) {
new AddAnnotationFix(Override.class.getName(), method)
.invoke(method.getProject(), null, mySourceClass.getContainingFile());
}
}
if (!PsiUtil.isLanguageLevel6OrHigher(mySourceClass) && myIsTargetInterface) {
if (isOriginalMethodAbstract) {
for (PsiMethod oMethod : OverridingMethodsSearch.search(method)) {
deleteOverrideAnnotationIfFound(oMethod);
}
}
deleteOverrideAnnotationIfFound(method);
}
myMembersAfterMove.add(movedElement);
// if (isOriginalMethodAbstract) {
method.delete();
// }
} else {
if (isOriginalMethodAbstract) {
PsiUtil.setModifierProperty(myTargetSuperClass, PsiModifier.ABSTRACT, true);
}
RefactoringUtil.replaceMovedMemberTypeParameters(
methodCopy, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory);
fixReferencesToStatic(methodCopy);
if (superClassMethod != null && superClassMethod.hasModifierProperty(PsiModifier.ABSTRACT)) {
superClassMethod.replace(convertMethodToLanguage(methodCopy, language));
} else {
final PsiMember movedElement =
anchor != null
? (PsiMember)
myTargetSuperClass.addBefore(
convertMethodToLanguage(methodCopy, language), anchor)
: (PsiMember)
myTargetSuperClass.addBefore(
convertMethodToLanguage(methodCopy, language),
myTargetSuperClass.getRBrace());
reformat(movedElement);
myMembersAfterMove.add(movedElement);
}
method.delete();
}
}
private PsiClass buildClass() {
final PsiManager manager = sourceClass.getManager();
final Project project = sourceClass.getProject();
final ExtractedClassBuilder extractedClassBuilder = new ExtractedClassBuilder();
extractedClassBuilder.setProject(myProject);
extractedClassBuilder.setClassName(newClassName);
extractedClassBuilder.setPackageName(newPackageName);
extractedClassBuilder.setOriginalClassName(sourceClass.getQualifiedName());
extractedClassBuilder.setRequiresBackPointer(requiresBackpointer);
extractedClassBuilder.setExtractAsEnum(enumConstants);
for (PsiField field : fields) {
extractedClassBuilder.addField(field);
}
for (PsiMethod method : methods) {
extractedClassBuilder.addMethod(method);
}
for (PsiClass innerClass : innerClasses) {
extractedClassBuilder.addInnerClass(
innerClass, innerClassesToMakePublic.contains(innerClass));
}
extractedClassBuilder.setTypeArguments(typeParams);
final List<PsiClass> interfaces = calculateInterfacesSupported();
extractedClassBuilder.setInterfaces(interfaces);
if (myGenerateAccessors) {
final NecessaryAccessorsVisitor visitor = checkNecessaryGettersSetters4ExtractedClass();
sourceClass.accept(visitor);
extractedClassBuilder.setFieldsNeedingGetters(visitor.getFieldsNeedingGetter());
extractedClassBuilder.setFieldsNeedingSetters(visitor.getFieldsNeedingSetter());
}
final String classString = extractedClassBuilder.buildBeanClass();
if (extractInnerClass) {
final PsiFileFactory factory = PsiFileFactory.getInstance(project);
final PsiJavaFile newFile =
(PsiJavaFile)
factory.createFileFromText(
newClassName + ".java", JavaFileType.INSTANCE, classString);
final PsiClass psiClass = newFile.getClasses()[0];
if (!psiClass.isEnum()) {
final PsiModifierList modifierList = psiClass.getModifierList();
assert modifierList != null;
modifierList.setModifierProperty(PsiModifier.STATIC, true);
}
final PsiElement addedClass = sourceClass.add(psiClass);
return (PsiClass)
CodeStyleManager.getInstance(manager)
.reformat(
JavaCodeStyleManager.getInstance(project).shortenClassReferences(addedClass));
}
try {
final PsiFile containingFile = sourceClass.getContainingFile();
final PsiDirectory directory;
final PsiDirectory containingDirectory = containingFile.getContainingDirectory();
if (myMoveDestination != null) {
directory = myMoveDestination.getTargetDirectory(containingDirectory);
} else {
final Module module = ModuleUtil.findModuleForPsiElement(containingFile);
assert module != null;
directory =
PackageUtil.findOrCreateDirectoryForPackage(
module, newPackageName, containingDirectory, false, true);
}
if (directory != null) {
final PsiFileFactory factory = PsiFileFactory.getInstance(project);
final PsiFile newFile =
factory.createFileFromText(newClassName + ".java", JavaFileType.INSTANCE, classString);
final PsiElement addedFile = directory.add(newFile);
final CodeStyleManager codeStyleManager =
CodeStyleManager.getInstance(manager.getProject());
final PsiElement shortenedFile =
JavaCodeStyleManager.getInstance(project).shortenClassReferences(addedFile);
return ((PsiJavaFile) codeStyleManager.reformat(shortenedFile)).getClasses()[0];
} else {
return null;
}
} catch (IncorrectOperationException e) {
return null;
}
}
private void doMoveMethod(PsiSubstitutor substitutor, GrMemberInfo info) {
GroovyPsiElementFactory elementFactory = GroovyPsiElementFactory.getInstance(myProject);
GrMethod method = (GrMethod) info.getMember();
PsiMethod sibling = method;
PsiMethod anchor = null;
while (sibling != null) {
sibling = PsiTreeUtil.getNextSiblingOfType(sibling, PsiMethod.class);
if (sibling != null) {
anchor =
MethodSignatureUtil.findMethodInSuperClassBySignatureInDerived(
method.getContainingClass(),
myTargetSuperClass,
sibling.getSignature(PsiSubstitutor.EMPTY),
false);
if (anchor != null) {
break;
}
}
}
GrMethod methodCopy = (GrMethod) method.copy();
if (method.findSuperMethods(myTargetSuperClass).length == 0) {
deleteOverrideAnnotationIfFound(methodCopy);
}
final boolean isOriginalMethodAbstract =
method.hasModifierProperty(PsiModifier.ABSTRACT)
|| method.hasModifierProperty(PsiModifier.DEFAULT);
if (myTargetSuperClass.isInterface() || info.isToAbstract()) {
GroovyChangeContextUtil.clearContextInfo(method);
RefactoringUtil.makeMethodAbstract(myTargetSuperClass, methodCopy);
if (myTargetSuperClass.isInterface()) {
PsiUtil.setModifierProperty(methodCopy, PsiModifier.ABSTRACT, false);
}
replaceMovedMemberTypeParameters(
methodCopy, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory);
final GrMethod movedElement =
anchor != null
? (GrMethod) myTargetSuperClass.addBefore(methodCopy, anchor)
: (GrMethod) myTargetSuperClass.add(methodCopy);
CodeStyleSettings styleSettings = CodeStyleSettingsManager.getSettings(method.getProject());
if (styleSettings.INSERT_OVERRIDE_ANNOTATION) {
if (PsiUtil.isLanguageLevel5OrHigher(mySourceClass) && !myTargetSuperClass.isInterface()
|| PsiUtil.isLanguageLevel6OrHigher(mySourceClass)) {
new AddAnnotationFix(CommonClassNames.JAVA_LANG_OVERRIDE, method)
.invoke(method.getProject(), null, mySourceClass.getContainingFile());
}
}
GrDocComment oldDoc = method.getDocComment();
if (oldDoc != null) {
GrDocCommentUtil.setDocComment(movedElement, oldDoc);
}
myDocCommentPolicy.processCopiedJavaDoc(
methodCopy.getDocComment(), oldDoc, isOriginalMethodAbstract);
myMembersAfterMove.add(movedElement);
if (isOriginalMethodAbstract) {
deleteMemberWithDocComment(method);
}
} else {
if (isOriginalMethodAbstract) {
PsiUtil.setModifierProperty(myTargetSuperClass, PsiModifier.ABSTRACT, true);
}
// fixReferencesToStatic(methodCopy, movedMembers);
replaceMovedMemberTypeParameters(
methodCopy, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory);
final PsiMethod superClassMethod =
myTargetSuperClass.findMethodBySignature(methodCopy, false);
final GrMethod movedElement;
if (superClassMethod != null && superClassMethod.hasModifierProperty(PsiModifier.ABSTRACT)) {
movedElement = (GrMethod) superClassMethod.replace(methodCopy);
} else {
movedElement =
anchor != null
? (GrMethod) myTargetSuperClass.addBefore(methodCopy, anchor)
: (GrMethod) myTargetSuperClass.add(methodCopy);
myMembersAfterMove.add(movedElement);
}
GrDocCommentUtil.setDocComment(movedElement, method.getDocComment());
deleteMemberWithDocComment(method);
}
}
