@Override
public boolean isMemberEnabled(MemberInfo member) {
final PsiClass currentSuperClass = getSuperClass();
if (currentSuperClass == null) return true;
if (myMemberInfoStorage.getDuplicatedMemberInfos(currentSuperClass).contains(member))
return false;
if (myMemberInfoStorage.getExtending(currentSuperClass).contains(member.getMember()))
return false;
final boolean isInterface = currentSuperClass.isInterface();
if (!isInterface) return true;
PsiElement element = member.getMember();
if (element instanceof PsiClass && ((PsiClass) element).isInterface()) return true;
if (element instanceof PsiField) {
return ((PsiModifierListOwner) element).hasModifierProperty(PsiModifier.STATIC);
}
if (element instanceof PsiMethod) {
final PsiSubstitutor superSubstitutor =
TypeConversionUtil.getSuperClassSubstitutor(
currentSuperClass, myClass, PsiSubstitutor.EMPTY);
final MethodSignature signature = ((PsiMethod) element).getSignature(superSubstitutor);
final PsiMethod superClassMethod =
MethodSignatureUtil.findMethodBySignature(currentSuperClass, signature, false);
if (superClassMethod != null && !PsiUtil.isLanguageLevel8OrHigher(currentSuperClass))
return false;
return !((PsiModifierListOwner) element).hasModifierProperty(PsiModifier.STATIC)
|| PsiUtil.isLanguageLevel8OrHigher(currentSuperClass);
}
return true;
}
@Override
public boolean isAbstractEnabled(MemberInfo member) {
PsiClass currentSuperClass = getSuperClass();
if (currentSuperClass == null || !currentSuperClass.isInterface()) return true;
if (PsiUtil.isLanguageLevel8OrHigher(currentSuperClass)) {
return true;
}
return false;
}
@Override
public boolean isAbstractWhenDisabled(MemberInfo member) {
PsiClass currentSuperClass = getSuperClass();
if (currentSuperClass == null) return false;
if (currentSuperClass.isInterface()) {
final PsiMember psiMember = member.getMember();
if (psiMember instanceof PsiMethod) {
return !psiMember.hasModifierProperty(PsiModifier.STATIC);
}
}
return false;
}
@Nullable
public static String getMemberQualifiedName(PsiMember member) {
if (member instanceof PsiClass) {
return ((PsiClass) member).getQualifiedName();
}
PsiClass containingClass = member.getContainingClass();
if (containingClass == null) return null;
String className = containingClass.getQualifiedName();
if (className == null) return null;
return className + "." + member.getName();
}
private boolean isAccessibleFrom(RefElement from, RefJavaElement to, String accessModifier) {
if (accessModifier == PsiModifier.PUBLIC) return true;
final RefJavaUtil refUtil = RefJavaUtil.getInstance();
if (accessModifier == PsiModifier.PACKAGE_LOCAL) {
return RefJavaUtil.getPackage(from) == RefJavaUtil.getPackage(to);
}
RefClass fromTopLevel = refUtil.getTopLevelClass(from);
RefClass toTopLevel = refUtil.getTopLevelClass(to);
RefClass fromOwner = refUtil.getOwnerClass(from);
RefClass toOwner = refUtil.getOwnerClass(to);
if (accessModifier == PsiModifier.PROTECTED) {
if (SUGGEST_PRIVATE_FOR_INNERS) {
return refUtil.isInheritor(fromTopLevel, toOwner)
|| fromOwner != null && refUtil.isInheritor(fromOwner, toTopLevel)
|| toOwner != null && refUtil.getOwnerClass(toOwner) == from;
}
return refUtil.isInheritor(fromTopLevel, toOwner);
}
if (accessModifier == PsiModifier.PRIVATE) {
if (SUGGEST_PRIVATE_FOR_INNERS) {
if (isInExtendsList(to, fromTopLevel.getElement().getExtendsList())) return false;
if (isInExtendsList(to, fromTopLevel.getElement().getImplementsList())) return false;
if (isInAnnotations(to, fromTopLevel)) return false;
return fromTopLevel == toOwner
|| fromOwner == toTopLevel
|| toOwner != null && refUtil.getOwnerClass(toOwner) == from;
}
if (fromOwner != null
&& fromOwner.isStatic()
&& !to.isStatic()
&& refUtil.isInheritor(fromOwner, toOwner)) return false;
if (fromTopLevel == toOwner) {
if (from instanceof RefClass && to instanceof RefClass) {
final PsiClass fromClass = ((RefClass) from).getElement();
LOG.assertTrue(fromClass != null);
if (isInExtendsList(to, fromClass.getExtendsList())) return false;
if (isInExtendsList(to, fromClass.getImplementsList())) return false;
}
return true;
}
}
return false;
}
private static int findOffsetToInsertMethodTo(Editor editor, PsiFile file) {
int result = editor.getCaretModel().getOffset();
PsiClass classAtCursor =
PsiTreeUtil.getParentOfType(file.findElementAt(result), PsiClass.class, false);
while (classAtCursor != null && !(classAtCursor.getParent() instanceof PsiFile)) {
result = classAtCursor.getTextRange().getEndOffset();
classAtCursor = PsiTreeUtil.getParentOfType(classAtCursor, PsiClass.class);
}
return result;
}
@Override
public int checkForProblems(@NotNull MemberInfo member) {
if (member.isChecked()) return OK;
PsiClass currentSuperClass = getSuperClass();
if (currentSuperClass != null && currentSuperClass.isInterface()) {
PsiMember element = member.getMember();
if (element.hasModifierProperty(PsiModifier.STATIC)) {
return super.checkForProblems(member);
}
return OK;
} else {
return super.checkForProblems(member);
}
}
public void execute(final String line, final int textEndOffset) {
myResult = null;
myInfo = parseExceptionLine(line);
if (myInfo == null) {
return;
}
myMethod = myInfo.getSecond().substring(line);
final int lparenthIndex = myInfo.third.getStartOffset();
final int rparenthIndex = myInfo.third.getEndOffset();
final String fileAndLine = line.substring(lparenthIndex + 1, rparenthIndex).trim();
final int colonIndex = fileAndLine.lastIndexOf(':');
if (colonIndex < 0) return;
final String lineString = fileAndLine.substring(colonIndex + 1);
try {
final int lineNumber = Integer.parseInt(lineString);
myClass = findPositionClass(line);
myFile =
myClass == null ? null : (PsiFile) myClass.getContainingFile().getNavigationElement();
if (myFile == null) {
// try find the file with the required name
PsiFile[] files =
PsiShortNamesCache.getInstance(myProject)
.getFilesByName(fileAndLine.substring(0, colonIndex).trim());
if (files.length > 0) {
myFile = files[0];
}
}
if (myFile == null) return;
/*
IDEADEV-4976: Some scramblers put something like SourceFile mock instead of real class name.
final String filePath = fileAndLine.substring(0, colonIndex).replace('/', File.separatorChar);
final int slashIndex = filePath.lastIndexOf(File.separatorChar);
final String shortFileName = slashIndex < 0 ? filePath : filePath.substring(slashIndex + 1);
if (!file.getName().equalsIgnoreCase(shortFileName)) return null;
*/
final int textStartOffset = textEndOffset - line.length();
final int highlightStartOffset = textStartOffset + lparenthIndex + 1;
final int highlightEndOffset = textStartOffset + rparenthIndex;
final VirtualFile virtualFile = myFile.getVirtualFile();
HyperlinkInfo linkInfo = new MyHyperlinkInfo(myProject, virtualFile, lineNumber);
TextAttributes attributes = HYPERLINK_ATTRIBUTES.clone();
if (!ProjectRootManager.getInstance(myProject).getFileIndex().isInContent(virtualFile)) {
Color color = UIUtil.getInactiveTextColor();
attributes.setForegroundColor(color);
attributes.setEffectColor(color);
}
myResult = new Filter.Result(highlightStartOffset, highlightEndOffset, linkInfo, attributes);
} catch (NumberFormatException e) {
//
}
}
protected void init() {
super.init();
final PsiClass psiClass = myMethod.getContainingClass();
if (psiClass == null) return;
if (psiClass.isInterface()) {
myDelegatePanel.setVisible(false);
}
if (myMethod.hasModifierProperty(GrModifier.PRIVATE)) {
myPrivateRadioButton.setSelected(true);
} else if (myMethod.hasModifierProperty(GrModifier.PROTECTED)) {
myProtectedRadioButton.setSelected(true);
} else if (myMethod.hasModifierProperty(GrModifier.PUBLIC)) {
myPublicRadioButton.setSelected(true);
}
}
private void invokeMoveToPackage() {
final MoveDestination destination = selectDestination();
if (destination == null) return;
saveRefactoringSettings();
for (final PsiElement element : myElementsToMove) {
String message = verifyDestinationForElement(element, destination);
if (message != null) {
String helpId = HelpID.getMoveHelpID(myElementsToMove[0]);
CommonRefactoringUtil.showErrorMessage(
RefactoringBundle.message("error.title"), message, helpId, getProject());
return;
}
}
try {
for (PsiElement element : myElementsToMove) {
if (element instanceof PsiClass) {
final PsiClass aClass = (PsiClass) element;
LOG.assertTrue(aClass.isPhysical(), aClass);
/*PsiElement toAdd;
if (aClass.getContainingFile() instanceof PsiJavaFile && ((PsiJavaFile)aClass.getContainingFile()).getClasses().length > 1) {
toAdd = aClass;
}
else {
toAdd = aClass.getContainingFile();
}*/
final PsiDirectory targetDirectory =
destination.getTargetIfExists(element.getContainingFile());
if (targetDirectory != null) {
MoveFilesOrDirectoriesUtil.checkMove(aClass, targetDirectory);
}
}
}
MoveClassesOrPackagesProcessor processor =
createMoveToPackageProcessor(destination, myElementsToMove, myMoveCallback);
if (processor.verifyValidPackageName()) {
processor.setOpenInEditor(isOpenInEditor());
invokeRefactoring(processor);
}
} catch (IncorrectOperationException e) {
String helpId = HelpID.getMoveHelpID(myElementsToMove[0]);
CommonRefactoringUtil.showErrorMessage(
RefactoringBundle.message("error.title"), e.getMessage(), helpId, getProject());
}
}
protected void doAction() {
if (!myCallback.checkConflicts(this)) return;
JavaRefactoringSettings.getInstance().PULL_UP_MEMBERS_JAVADOC = myJavaDocPanel.getPolicy();
final PsiClass superClass = getSuperClass();
String name = superClass.getQualifiedName();
if (name != null) {
StatisticsManager.getInstance()
.incUseCount(
new StatisticsInfo(PULL_UP_STATISTICS_KEY + myClass.getQualifiedName(), name));
}
List<MemberInfo> infos = getSelectedMemberInfos();
invokeRefactoring(
new PullUpProcessor(
myClass,
superClass,
infos.toArray(new MemberInfo[infos.size()]),
new DocCommentPolicy(getJavaDocPolicy())));
close(OK_EXIT_CODE);
}
protected PsiClass getPreselection() {
PsiClass preselection = RefactoringHierarchyUtil.getNearestBaseClass(myClass, false);
final String statKey = PULL_UP_STATISTICS_KEY + myClass.getQualifiedName();
for (StatisticsInfo info : StatisticsManager.getInstance().getAllValues(statKey)) {
final String superClassName = info.getValue();
PsiClass superClass = null;
for (PsiClass aClass : mySuperClasses) {
if (Comparing.strEqual(superClassName, aClass.getQualifiedName())) {
superClass = aClass;
break;
}
}
if (superClass != null && StatisticsManager.getInstance().getUseCount(info) > 0) {
preselection = superClass;
break;
}
}
return preselection;
}
@Nullable
private String verifyInnerClassDestination() {
PsiClass targetClass = findTargetClass();
if (targetClass == null) return null;
for (PsiElement element : myElementsToMove) {
if (PsiTreeUtil.isAncestor(element, targetClass, false)) {
return RefactoringBundle.message("move.class.to.inner.move.to.self.error");
}
final Language targetClassLanguage = targetClass.getLanguage();
if (!element.getLanguage().equals(targetClassLanguage)) {
return RefactoringBundle.message(
"move.to.different.language",
UsageViewUtil.getType(element),
((PsiClass) element).getQualifiedName(),
targetClass.getQualifiedName());
}
if (element.getLanguage().equals(Language.findLanguageByID("Groovy"))) {
return RefactoringBundle.message("dont.support.inner.classes", "Groovy");
}
}
while (targetClass != null) {
if (targetClass.getContainingClass() != null
&& !targetClass.hasModifierProperty(PsiModifier.STATIC)) {
return RefactoringBundle.message("move.class.to.inner.nonstatic.error");
}
targetClass = targetClass.getContainingClass();
}
return null;
}
@Override
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
if (!FileModificationService.getInstance()
.preparePsiElementForWrite(descriptor.getPsiElement())) return;
final PsiModifierListOwner element =
PsiTreeUtil.getParentOfType(descriptor.getPsiElement(), PsiModifierListOwner.class);
if (element != null) {
RefElement refElement = null;
if (myManager != null) {
refElement = myManager.getReference(element);
}
try {
if (element instanceof PsiVariable) {
((PsiVariable) element).normalizeDeclaration();
}
PsiModifierList list = element.getModifierList();
LOG.assertTrue(list != null);
if (element instanceof PsiMethod) {
PsiMethod psiMethod = (PsiMethod) element;
PsiClass containingClass = psiMethod.getContainingClass();
if (containingClass != null
&& containingClass.getParent() instanceof PsiFile
&& myHint == PsiModifier.PRIVATE
&& list.hasModifierProperty(PsiModifier.FINAL)) {
list.setModifierProperty(PsiModifier.FINAL, false);
}
}
list.setModifierProperty(myHint, true);
if (refElement instanceof RefJavaElement) {
RefJavaUtil.getInstance().setAccessModifier((RefJavaElement) refElement, myHint);
}
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
}
@NotNull
private List<PsiMethod> getMethodsToImport() {
PsiShortNamesCache cache = PsiShortNamesCache.getInstance(myMethodCall.getProject());
PsiMethodCallExpression element = myMethodCall.getElement();
PsiReferenceExpression reference = element.getMethodExpression();
PsiExpressionList argumentList = element.getArgumentList();
String name = reference.getReferenceName();
List<PsiMethod> list = new ArrayList<PsiMethod>();
if (name == null) return list;
GlobalSearchScope scope = element.getResolveScope();
PsiMethod[] methods = cache.getMethodsByNameIfNotMoreThan(name, scope, 20);
List<PsiMethod> applicableList = new ArrayList<PsiMethod>();
final PsiResolveHelper resolveHelper =
JavaPsiFacade.getInstance(element.getProject()).getResolveHelper();
for (PsiMethod method : methods) {
ProgressManager.checkCanceled();
if (JavaCompletionUtil.isInExcludedPackage(method)) continue;
if (!method.hasModifierProperty(PsiModifier.STATIC)) continue;
PsiFile file = method.getContainingFile();
if (file instanceof PsiJavaFile
// do not show methods from default package
&& ((PsiJavaFile) file).getPackageName().length() != 0
&& PsiUtil.isAccessible(method, element, method.getContainingClass())) {
list.add(method);
PsiSubstitutor substitutorForMethod =
resolveHelper.inferTypeArguments(
method.getTypeParameters(),
method.getParameterList().getParameters(),
argumentList.getExpressions(),
PsiSubstitutor.EMPTY,
element.getParent(),
DefaultParameterTypeInferencePolicy.INSTANCE);
if (PsiUtil.isApplicable(method, substitutorForMethod, argumentList)) {
applicableList.add(method);
}
}
}
List<PsiMethod> result = applicableList.isEmpty() ? list : applicableList;
for (int i = result.size() - 1; i >= 0; i--) {
ProgressManager.checkCanceled();
PsiMethod method = result.get(i);
PsiClass containingClass = method.getContainingClass();
for (int j = i + 1; j < result.size(); j++) {
PsiMethod exMethod = result.get(j);
if (!Comparing.strEqual(exMethod.getName(), method.getName())) continue;
PsiClass exContainingClass = exMethod.getContainingClass();
if (containingClass != null
&& exContainingClass != null
&& !Comparing.equal(
containingClass.getQualifiedName(), exContainingClass.getQualifiedName())) continue;
// same named methods, drop one
result.remove(i);
break;
}
// check for manually excluded
if (isExcluded(method)) {
result.remove(i);
}
}
Collections.sort(result, new PsiProximityComparator(argumentList));
return result;
}
