protected boolean invokeImpl(
final Project project, final PsiLocalVariable localVariable, final Editor editor) {
final PsiElement parent = localVariable.getParent();
if (!(parent instanceof PsiDeclarationStatement)) {
String message =
RefactoringBundle.getCannotRefactorMessage(
RefactoringBundle.message("error.wrong.caret.position.local.or.expression.name"));
CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, getHelpID());
return false;
}
final LocalToFieldHandler localToFieldHandler =
new LocalToFieldHandler(project, true) {
@Override
protected Settings showRefactoringDialog(
PsiClass aClass,
PsiLocalVariable local,
PsiExpression[] occurences,
boolean isStatic) {
return IntroduceConstantHandler.this.showRefactoringDialog(
project,
editor,
aClass,
local.getInitializer(),
local.getType(),
occurences,
local,
null);
}
};
return localToFieldHandler.convertLocalToField(localVariable, editor);
}
public DelegationPanel() {
final BoxLayout boxLayout = new BoxLayout(this, BoxLayout.X_AXIS);
setLayout(boxLayout);
add(new JLabel(RefactoringBundle.message("delegation.panel.method.calls.label")));
myRbModifyCalls = new JRadioButton();
myRbModifyCalls.setText(RefactoringBundle.message("delegation.panel.modify.radio"));
add(myRbModifyCalls);
myRbGenerateDelegate = new JRadioButton();
myRbGenerateDelegate.setText(
RefactoringBundle.message("delegation.panel.delegate.via.overloading.method"));
add(myRbGenerateDelegate);
myRbModifyCalls.setSelected(true);
final ButtonGroup bg = new ButtonGroup();
bg.add(myRbModifyCalls);
bg.add(myRbGenerateDelegate);
add(Box.createHorizontalGlue());
myRbModifyCalls.addItemListener(
new ItemListener() {
public void itemStateChanged(ItemEvent e) {
stateModified();
}
});
myRbGenerateDelegate.addItemListener(
new ItemListener() {
public void itemStateChanged(ItemEvent e) {
stateModified();
}
});
}
@Nullable
private MoveDestination selectDestination() {
final String packageName = getTargetPackage().trim();
if (packageName.length() > 0
&& !JavaPsiFacade.getInstance(myManager.getProject())
.getNameHelper()
.isQualifiedName(packageName)) {
Messages.showErrorDialog(
myProject,
RefactoringBundle.message("please.enter.a.valid.target.package.name"),
RefactoringBundle.message("move.title"));
return null;
}
RecentsManager.getInstance(myProject).registerRecentEntry(RECENTS_KEY, packageName);
PackageWrapper targetPackage = new PackageWrapper(myManager, packageName);
if (!targetPackage.exists()) {
final int ret =
Messages.showYesNoDialog(
myProject,
RefactoringBundle.message("package.does.not.exist", packageName),
RefactoringBundle.message("move.title"),
Messages.getQuestionIcon());
if (ret != 0) return null;
}
return ((DestinationFolderComboBox) myDestinationFolderCB).selectDirectory(targetPackage, true);
}
public void doClone(PsiElement element) {
FeatureUsageTracker.getInstance().triggerFeatureUsed("refactoring.copyClass");
PsiClass[] classes = getTopLevelClasses(element);
if (classes == null) {
CopyFilesOrDirectoriesHandler.doCloneFile(element);
return;
}
Project project = element.getProject();
CopyClassDialog dialog = new CopyClassDialog(classes[0], null, project, true);
dialog.setTitle(RefactoringBundle.message("copy.handler.clone.class"));
dialog.show();
if (dialog.isOK()) {
String className = dialog.getClassName();
PsiDirectory targetDirectory = element.getContainingFile().getContainingDirectory();
copyClassesImpl(
className,
project,
Collections.singletonMap(classes[0].getContainingFile(), classes),
null,
targetDirectory,
targetDirectory,
RefactoringBundle.message("copy.handler.clone.class"),
true,
true);
}
}
public static void checkFieldConflicts(
@Nullable PsiClass aClass, String newName, final Map<PsiElement, String> conflicts) {
PsiField existingField = aClass != null ? aClass.findFieldByName(newName, true) : null;
if (existingField != null) {
if (aClass.equals(existingField.getContainingClass())) {
String className =
aClass instanceof PsiAnonymousClass
? RefactoringBundle.message("current.class")
: RefactoringUIUtil.getDescription(aClass, false);
final String conflict =
RefactoringBundle.message(
"field.0.is.already.defined.in.the.1", existingField.getName(), className);
conflicts.put(existingField, conflict);
} else { // method somewhere in base class
if (!existingField.hasModifierProperty(PsiModifier.PRIVATE)) {
String fieldInfo =
PsiFormatUtil.formatVariable(
existingField,
PsiFormatUtil.SHOW_NAME | PsiFormatUtil.SHOW_TYPE | PsiFormatUtil.TYPE_AFTER,
PsiSubstitutor.EMPTY);
String className =
RefactoringUIUtil.getDescription(existingField.getContainingClass(), false);
final String descr =
RefactoringBundle.message(
"field.0.will.hide.field.1.of.the.base.class", newName, fieldInfo, className);
conflicts.put(existingField, descr);
}
}
}
}
@Override
public void visitReferenceExpression(GrReferenceExpression referenceExpression) {
final PsiElement resolved = referenceExpression.resolve();
if (resolved instanceof PsiVariable) {
if (!isStaticFinalField((PsiVariable) resolved)) {
if (expr instanceof GrClosableBlock) {
if (!PsiTreeUtil.isContextAncestor(scope, resolved, true)) {
throw new GrRefactoringError(
GroovyRefactoringBundle.message("closure.uses.external.variables"));
}
} else {
throw new GrRefactoringError(
RefactoringBundle.message("selected.expression.cannot.be.a.constant.initializer"));
}
}
} else if (resolved instanceof PsiMethod
&& ((PsiMethod) resolved).getContainingClass() != null) {
final GrExpression qualifier = referenceExpression.getQualifierExpression();
if (qualifier == null
|| (qualifier instanceof GrReferenceExpression
&& ((GrReferenceExpression) qualifier).resolve() instanceof PsiClass)) {
if (!((PsiMethod) resolved).hasModifierProperty(PsiModifier.STATIC)) {
throw new GrRefactoringError(
RefactoringBundle.message("selected.expression.cannot.be.a.constant.initializer"));
}
}
}
}
private static void checkInterfaceTarget(
MemberInfoBase<? extends PsiMember>[] infos, MultiMap<PsiElement, String> conflictsList) {
for (MemberInfoBase<? extends PsiMember> info : infos) {
PsiElement member = info.getMember();
if (member instanceof PsiField || member instanceof PsiClass) {
if (!((PsiModifierListOwner) member).hasModifierProperty(PsiModifier.STATIC)
&& !(member instanceof PsiClass && ((PsiClass) member).isInterface())) {
String message =
RefactoringBundle.message(
"0.is.not.static.it.cannot.be.moved.to.the.interface",
RefactoringUIUtil.getDescription(member, false));
message = CommonRefactoringUtil.capitalize(message);
conflictsList.putValue(member, message);
}
}
if (member instanceof PsiField && ((PsiField) member).getInitializer() == null) {
String message =
RefactoringBundle.message(
"0.is.not.initialized.in.declaration.such.fields.are.not.allowed.in.interfaces",
RefactoringUIUtil.getDescription(member, false));
conflictsList.putValue(member, CommonRefactoringUtil.capitalize(message));
}
}
}
public void invoke(
@NotNull Project project, Editor editor, PsiFile file, DataContext dataContext) {
int offset = editor.getCaretModel().getOffset();
editor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE);
PsiElement element = file.findElementAt(offset);
while (true) {
if (element == null || element instanceof PsiFile) {
String message =
RefactoringBundle.getCannotRefactorMessage(
RefactoringBundle.message(
"the.caret.should.be.positioned.inside.a.class.to.push.members.from"));
CommonRefactoringUtil.showErrorHint(
project, editor, message, REFACTORING_NAME, HelpID.MEMBERS_PUSH_DOWN);
return;
}
if (element instanceof PsiClass
|| element instanceof PsiField
|| element instanceof PsiMethod) {
if (element instanceof JspClass) {
RefactoringMessageUtil.showNotSupportedForJspClassesError(
project, editor, REFACTORING_NAME, HelpID.MEMBERS_PUSH_DOWN);
return;
}
invoke(project, new PsiElement[] {element}, dataContext);
return;
}
element = element.getParent();
}
}
@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;
}
protected void doOKAction() {
CommandProcessor.getInstance()
.executeCommand(
myProject,
new Runnable() {
public void run() {
final Runnable action =
new Runnable() {
public void run() {
String directoryName =
myTargetDirectoryField.getText().replace(File.separatorChar, '/');
try {
myTargetDirectory =
DirectoryUtil.mkdirs(
PsiManager.getInstance(myProject), directoryName);
} catch (IncorrectOperationException e) {
}
}
};
ApplicationManager.getApplication().runWriteAction(action);
}
},
RefactoringBundle.message("create.directory"),
null);
if (myTargetDirectory == null) {
CommonRefactoringUtil.showErrorMessage(
getTitle(), RefactoringBundle.message("cannot.create.directory"), myHelpID, myProject);
return;
}
myCallback.run(this);
}
@Nullable
private static String getCannotRefactorMessage(PsiMember member) {
if (member == null) {
return RefactoringBundle.message("locate.caret.inside.a.method");
}
if (member instanceof PsiMethod) {
if (((PsiMethod) member).isConstructor()) {
return RefactoringBundle.message("replace.with.method.call.does.not.work.for.constructors");
}
final PsiCodeBlock body = ((PsiMethod) member).getBody();
if (body == null) {
return RefactoringBundle.message("method.does.not.have.a.body", member.getName());
}
final PsiStatement[] statements = body.getStatements();
if (statements.length == 0) {
return RefactoringBundle.message("method.has.an.empty.body", member.getName());
}
} else if (member instanceof PsiField) {
final PsiField field = (PsiField) member;
if (field.getInitializer() == null) {
return "Field " + member.getName() + " doesn't have initializer";
}
final PsiClass containingClass = field.getContainingClass();
if (!field.hasModifierProperty(PsiModifier.FINAL)
|| !field.hasModifierProperty(PsiModifier.STATIC)
|| containingClass == null
|| containingClass.getQualifiedName() == null) {
return "Replace Duplicates works with constants only";
}
} else {
return "Caret should be inside method or constant";
}
return null;
}
protected void performRefactoring(
Project project,
PsiDirectory directory,
PsiPackage aPackage,
boolean searchInComments,
boolean searchForTextOccurences) {
final VirtualFile sourceRoot =
ProjectRootManager.getInstance(project)
.getFileIndex()
.getSourceRootForFile(directory.getVirtualFile());
if (sourceRoot == null) {
Messages.showErrorDialog(
project,
RefactoringBundle.message("destination.directory.does.not.correspond.to.any.package"),
RefactoringBundle.message("cannot.move"));
return;
}
final JavaRefactoringFactory factory = JavaRefactoringFactory.getInstance(project);
final MoveDestination destination =
myPreserveSourceRoot.isSelected() && myPreserveSourceRoot.isVisible()
? factory.createSourceFolderPreservingMoveDestination(aPackage.getQualifiedName())
: factory.createSourceRootMoveDestination(aPackage.getQualifiedName(), sourceRoot);
MoveClassesOrPackagesProcessor processor =
new MoveClassesOrPackagesProcessor(
myDirectory.getProject(),
myElementsToMove,
destination,
searchInComments,
searchForTextOccurences,
myMoveCallback);
if (processor.verifyValidPackageName()) {
processor.run();
}
}
public Collection<PsiElement> getAdditionalElementsToDelete(
@NotNull final PsiElement element,
@NotNull final Collection<PsiElement> allElementsToDelete,
final boolean askUser) {
if (element instanceof PsiField) {
PsiField field = (PsiField) element;
final Project project = element.getProject();
String propertyName =
JavaCodeStyleManager.getInstance(project)
.variableNameToPropertyName(field.getName(), VariableKind.FIELD);
PsiClass aClass = field.getContainingClass();
if (aClass != null) {
boolean isStatic = field.hasModifierProperty(PsiModifier.STATIC);
PsiMethod[] getters =
GetterSetterPrototypeProvider.findGetters(aClass, propertyName, isStatic);
if (getters != null) {
final List<PsiMethod> validGetters = new ArrayList<>(1);
for (PsiMethod getter : getters) {
if (!allElementsToDelete.contains(getter) && (getter != null && getter.isPhysical())) {
validGetters.add(getter);
}
}
getters =
validGetters.isEmpty()
? null
: validGetters.toArray(new PsiMethod[validGetters.size()]);
}
PsiMethod setter = PropertyUtil.findPropertySetter(aClass, propertyName, isStatic, false);
if (allElementsToDelete.contains(setter) || setter != null && !setter.isPhysical())
setter = null;
if (askUser && (getters != null || setter != null)) {
final String message =
RefactoringMessageUtil.getGetterSetterMessage(
field.getName(),
RefactoringBundle.message("delete.title"),
getters != null ? getters[0] : null,
setter);
if (!ApplicationManager.getApplication().isUnitTestMode()
&& Messages.showYesNoDialog(
project,
message,
RefactoringBundle.message("safe.delete.title"),
Messages.getQuestionIcon())
!= Messages.YES) {
getters = null;
setter = null;
}
}
List<PsiElement> elements = new ArrayList<>();
if (setter != null) elements.add(setter);
if (getters != null) Collections.addAll(elements, getters);
return elements;
}
}
return null;
}
protected JComponent createNorthPanel() {
myNameField = new NameSuggestionsField(myProject);
myNameChangedListener =
new NameSuggestionsField.DataChanged() {
public void dataChanged() {
updateOkStatus();
}
};
myNameField.addDataChangedListener(myNameChangedListener);
JPanel panel = new JPanel(new GridBagLayout());
GridBagConstraints gbConstraints = new GridBagConstraints();
gbConstraints.insets = JBUI.insets(4);
gbConstraints.anchor = GridBagConstraints.WEST;
gbConstraints.fill = GridBagConstraints.BOTH;
gbConstraints.gridwidth = 1;
gbConstraints.weightx = 0;
gbConstraints.weighty = 0;
gbConstraints.gridx = 0;
gbConstraints.gridy = 0;
JLabel type = new JLabel(RefactoringBundle.message("variable.of.type"));
panel.add(type, gbConstraints);
gbConstraints.gridx++;
myTypeSelector = myTypeSelectorManager.getTypeSelector();
panel.add(myTypeSelector.getComponent(), gbConstraints);
gbConstraints.gridwidth = 1;
gbConstraints.weightx = 0;
gbConstraints.weighty = 0;
gbConstraints.gridx = 0;
gbConstraints.gridy = 1;
JLabel namePrompt = new JLabel(RefactoringBundle.message("name.prompt"));
namePrompt.setLabelFor(myNameField.getComponent());
panel.add(namePrompt, gbConstraints);
gbConstraints.gridwidth = 1;
gbConstraints.weightx = 1;
gbConstraints.gridx = 1;
gbConstraints.gridy = 1;
panel.add(myNameField.getComponent(), gbConstraints);
myNameSuggestionsManager =
new NameSuggestionsManager(
myTypeSelector,
myNameField,
new NameSuggestionsGenerator() {
public SuggestedNameInfo getSuggestedNameInfo(PsiType type) {
return IntroduceVariableBase.getSuggestedName(type, myExpression);
}
});
myNameSuggestionsManager.setLabelsFor(type, namePrompt);
return panel;
}
public static void checkMethodConflicts(
@Nullable PsiClass aClass,
PsiMethod refactoredMethod,
PsiMethod prototype,
final MultiMap<PsiElement, String> conflicts) {
if (prototype == null) return;
PsiMethod method = aClass != null ? aClass.findMethodBySignature(prototype, true) : null;
if (method != null && method != refactoredMethod) {
if (aClass.equals(method.getContainingClass())) {
final String classDescr =
aClass instanceof PsiAnonymousClass
? RefactoringBundle.message("current.class")
: RefactoringUIUtil.getDescription(aClass, false);
conflicts.putValue(
method,
RefactoringBundle.message(
"method.0.is.already.defined.in.the.1",
getMethodPrototypeString(prototype),
classDescr));
} else { // method somewhere in base class
if (JavaPsiFacade.getInstance(method.getProject())
.getResolveHelper()
.isAccessible(method, aClass, null)) {
String protoMethodInfo = getMethodPrototypeString(prototype);
String className =
CommonRefactoringUtil.htmlEmphasize(
UsageViewUtil.getDescriptiveName(method.getContainingClass()));
if (PsiUtil.getAccessLevel(prototype.getModifierList())
>= PsiUtil.getAccessLevel(method.getModifierList())) {
boolean isMethodAbstract = method.hasModifierProperty(PsiModifier.ABSTRACT);
boolean isMyMethodAbstract =
refactoredMethod != null
&& refactoredMethod.hasModifierProperty(PsiModifier.ABSTRACT);
final String conflict =
isMethodAbstract != isMyMethodAbstract
? RefactoringBundle.message(
"method.0.will.implement.method.of.the.base.class",
protoMethodInfo,
className)
: RefactoringBundle.message(
"method.0.will.override.a.method.of.the.base.class",
protoMethodInfo,
className);
conflicts.putValue(method, conflict);
} else { // prototype is private, will be compile-error
conflicts.putValue(
method,
RefactoringBundle.message(
"method.0.will.hide.method.of.the.base.class", protoMethodInfo, className));
}
}
}
}
}
private static boolean askToRenameAccesors(
PsiMethod getter, PsiMethod setter, String newName, final Project project) {
if (ApplicationManager.getApplication().isUnitTestMode()) return false;
String text =
RefactoringMessageUtil.getGetterSetterMessage(
newName, RefactoringBundle.message("rename.title"), getter, setter);
return Messages.showYesNoDialog(
project, text, RefactoringBundle.message("rename.title"), Messages.getQuestionIcon())
== 0;
}
@Nullable
private static String getCannotInlineMessage(
final PsiParameter psiParameter, final PsiMethod method) {
if (psiParameter.isVarArgs()) {
return RefactoringBundle.message("inline.parameter.error.varargs");
}
if (method.findSuperMethods().length > 0
|| OverridingMethodsSearch.search(method, true).toArray(PsiMethod.EMPTY_ARRAY).length > 0) {
return RefactoringBundle.message("inline.parameter.error.hierarchy");
}
return null;
}
private void replaceDuplicates(
final String includePath,
final List<IncludeDuplicate<T>> duplicates,
final Editor editor,
final Project project) {
if (duplicates.size() > 0) {
final String message =
RefactoringBundle.message(
"idea.has.found.fragments.that.can.be.replaced.with.include.directive",
ApplicationNamesInfo.getInstance().getProductName());
final int exitCode =
Messages.showYesNoDialog(
project, message, getRefactoringName(), Messages.getInformationIcon());
if (exitCode == DialogWrapper.OK_EXIT_CODE) {
CommandProcessor.getInstance()
.executeCommand(
project,
new Runnable() {
public void run() {
boolean replaceAll = false;
for (IncludeDuplicate<T> pair : duplicates) {
if (!replaceAll) {
highlightInEditor(project, pair, editor);
ReplacePromptDialog promptDialog =
new ReplacePromptDialog(
false, RefactoringBundle.message("replace.fragment"), project);
promptDialog.show();
final int promptResult = promptDialog.getExitCode();
if (promptResult == FindManager.PromptResult.SKIP) continue;
if (promptResult == FindManager.PromptResult.CANCEL) break;
if (promptResult == FindManager.PromptResult.OK) {
doReplaceRange(includePath, pair.getStart(), pair.getEnd());
} else if (promptResult == FindManager.PromptResult.ALL) {
doReplaceRange(includePath, pair.getStart(), pair.getEnd());
replaceAll = true;
} else {
LOG.error("Unknown return status");
}
} else {
doReplaceRange(includePath, pair.getStart(), pair.getEnd());
}
}
}
},
RefactoringBundle.message("remove.duplicates.command"),
null);
}
}
}
public static void buildPackagePrefixChangedMessage(
final VirtualFile[] virtualFiles, StringBuffer message, final String qualifiedName) {
if (virtualFiles.length > 0) {
message.append(
RefactoringBundle.message(
"package.occurs.in.package.prefixes.of.the.following.source.folders.n",
qualifiedName));
for (final VirtualFile virtualFile : virtualFiles) {
message.append(virtualFile.getPresentableUrl()).append("\n");
}
message.append(RefactoringBundle.message("these.package.prefixes.will.be.changed"));
}
}
protected JPanel createReplaceFieldsWithGettersPanel() {
JPanel radioButtonPanel = new JPanel(new GridBagLayout());
GridBagConstraints gbConstraints = new GridBagConstraints();
gbConstraints.insets = new Insets(4, 8, 4, 8);
gbConstraints.weighty = 1;
gbConstraints.weightx = 1;
gbConstraints.gridy = 0;
gbConstraints.gridwidth = GridBagConstraints.REMAINDER;
gbConstraints.fill = GridBagConstraints.BOTH;
gbConstraints.anchor = GridBagConstraints.WEST;
radioButtonPanel.add(
new JLabel(
RefactoringBundle.message("replace.fields.used.in.expressions.with.their.getters")),
gbConstraints);
myReplaceFieldsWithGettersNoneRadio = new JRadioButton();
myReplaceFieldsWithGettersNoneRadio.setText(RefactoringBundle.message("do.not.replace"));
myReplaceFieldsWithGettersInaccessibleRadio = new JRadioButton();
myReplaceFieldsWithGettersInaccessibleRadio.setText(
RefactoringBundle.message("replace.fields.inaccessible.in.usage.context"));
myReplaceFieldsWithGettersAllRadio = new JRadioButton();
myReplaceFieldsWithGettersAllRadio.setText(RefactoringBundle.message("replace.all.fields"));
gbConstraints.gridy++;
radioButtonPanel.add(myReplaceFieldsWithGettersNoneRadio, gbConstraints);
gbConstraints.gridy++;
radioButtonPanel.add(myReplaceFieldsWithGettersInaccessibleRadio, gbConstraints);
gbConstraints.gridy++;
radioButtonPanel.add(myReplaceFieldsWithGettersAllRadio, gbConstraints);
final int currentSetting =
JavaRefactoringSettings.getInstance().INTRODUCE_PARAMETER_REPLACE_FIELDS_WITH_GETTERS;
myReplaceFieldsWithGettersButtonGroup.add(myReplaceFieldsWithGettersNoneRadio);
myReplaceFieldsWithGettersButtonGroup.add(myReplaceFieldsWithGettersInaccessibleRadio);
myReplaceFieldsWithGettersButtonGroup.add(myReplaceFieldsWithGettersAllRadio);
if (currentSetting == IntroduceParameterRefactoring.REPLACE_FIELDS_WITH_GETTERS_ALL) {
myReplaceFieldsWithGettersAllRadio.setSelected(true);
} else if (currentSetting
== IntroduceParameterRefactoring.REPLACE_FIELDS_WITH_GETTERS_INACCESSIBLE) {
myReplaceFieldsWithGettersInaccessibleRadio.setSelected(true);
} else if (currentSetting == IntroduceParameterRefactoring.REPLACE_FIELDS_WITH_GETTERS_NONE) {
myReplaceFieldsWithGettersNoneRadio.setSelected(true);
}
return radioButtonPanel;
}
private void setNewName(@NotNull String newName) {
if (myPrimaryElement == null) {
myCommandName = RefactoringBundle.message("renaming.something");
return;
}
myNewName = newName;
myAllRenames.put(myPrimaryElement, newName);
myCommandName =
RefactoringBundle.message(
"renaming.0.1.to.2",
UsageViewUtil.getType(myPrimaryElement),
UsageViewUtil.getDescriptiveName(myPrimaryElement),
newName);
}
private static ElementToWorkOn getElementToWorkOn(
final Editor editor,
final PsiFile file,
final String refactoringName,
final String helpId,
final Project project,
PsiLocalVariable localVar,
PsiExpression expr) {
int startOffset = 0;
int endOffset = 0;
if (localVar == null && expr == null) {
startOffset = editor.getSelectionModel().getSelectionStart();
endOffset = editor.getSelectionModel().getSelectionEnd();
expr = CodeInsightUtil.findExpressionInRange(file, startOffset, endOffset);
if (expr == null) {
PsiIdentifier ident =
CodeInsightUtil.findElementInRange(file, startOffset, endOffset, PsiIdentifier.class);
if (ident != null) {
localVar = PsiTreeUtil.getParentOfType(ident, PsiLocalVariable.class);
}
}
}
if (expr == null && localVar == null) {
PsiElement[] statements = CodeInsightUtil.findStatementsInRange(file, startOffset, endOffset);
if (statements.length == 1 && statements[0] instanceof PsiExpressionStatement) {
expr = ((PsiExpressionStatement) statements[0]).getExpression();
} else if (statements.length == 1 && statements[0] instanceof PsiDeclarationStatement) {
PsiDeclarationStatement decl = (PsiDeclarationStatement) statements[0];
PsiElement[] declaredElements = decl.getDeclaredElements();
if (declaredElements.length == 1 && declaredElements[0] instanceof PsiLocalVariable) {
localVar = (PsiLocalVariable) declaredElements[0];
}
}
}
if (localVar == null && expr == null) {
expr = IntroduceVariableBase.getSelectedExpression(project, file, startOffset, endOffset);
}
if (localVar == null && expr == null) {
String message =
RefactoringBundle.getCannotRefactorMessage(
RefactoringBundle.message("error.wrong.caret.position.local.or.expression.name"));
CommonRefactoringUtil.showErrorHint(project, editor, message, refactoringName, helpId);
return null;
}
return new ElementToWorkOn(localVar, expr);
}
public boolean checkConflicts(final ExtractSuperclassDialog dialog) {
final MemberInfo[] infos =
ArrayUtil.toObjectArray(dialog.getSelectedMemberInfos(), MemberInfo.class);
final PsiDirectory targetDirectory = dialog.getTargetDirectory();
final PsiPackage targetPackage;
if (targetDirectory != null) {
targetPackage = JavaDirectoryService.getInstance().getPackage(targetDirectory);
} else {
targetPackage = null;
}
final MultiMap<PsiElement, String> conflicts = new MultiMap<PsiElement, String>();
if (!ProgressManager.getInstance()
.runProcessWithProgressSynchronously(
new Runnable() {
public void run() {
final PsiClass superClass =
mySubclass.getExtendsListTypes().length > 0 ? mySubclass.getSuperClass() : null;
conflicts.putAllValues(
PullUpConflictsUtil.checkConflicts(
infos,
mySubclass,
superClass,
targetPackage,
targetDirectory,
dialog.getContainmentVerifier(),
false));
}
},
RefactoringBundle.message("detecting.possible.conflicts"),
true,
myProject)) return false;
ExtractSuperClassUtil.checkSuperAccessible(targetDirectory, conflicts, mySubclass);
return ExtractSuperClassUtil.showConflicts(dialog, conflicts, myProject);
}
@Override
public Collection<String> findConflicts(
PsiElement element, PsiElement[] elements, UsageInfo[] usages) {
String methodRefFound = null;
if (!ApplicationManager.getApplication().isUnitTestMode()
&& (element instanceof PsiMethod || element instanceof PsiParameter)) {
for (UsageInfo usage : usages) {
final PsiElement refElement = usage.getElement();
if (refElement instanceof PsiMethodReferenceExpression) {
methodRefFound = RefactoringBundle.message("expand.method.reference.warning");
break;
}
}
}
if (methodRefFound != null) {
Collection<String> result = new ArrayList<>();
result.add(methodRefFound);
final Collection<String> conflicts = super.findConflicts(element, elements, usages);
if (conflicts != null) {
result.addAll(conflicts);
}
return result;
}
return super.findConflicts(element, elements, usages);
}
private static void invoke(final PsiClass aClass, Editor editor) {
final PsiTypeParameterList typeParameterList = aClass.getTypeParameterList();
Project project = aClass.getProject();
if (typeParameterList == null) {
final String message =
RefactoringBundle.getCannotRefactorMessage(
RefactoringBundle.message("changeClassSignature.no.type.parameters"));
CommonRefactoringUtil.showErrorHint(
project, editor, message, REFACTORING_NAME, HelpID.CHANGE_CLASS_SIGNATURE);
return;
}
if (!CommonRefactoringUtil.checkReadOnlyStatus(project, aClass)) return;
ChangeClassSignatureDialog dialog = new ChangeClassSignatureDialog(aClass);
dialog.show();
}
public MoveFilesOrDirectoriesDialog(Project project, Callback callback) {
super(project, true);
myProject = project;
myCallback = callback;
setTitle(RefactoringBundle.message("move.title"));
init();
}
protected void createRemoveParamsPanel(GridBagConstraints gbConstraints, JPanel panel) {
final JCheckBox[] removeParamsCb = new JCheckBox[myParametersToRemove.length];
for (int i = 0; i < myParametersToRemove.length; i++) {
PsiParameter parameter = myParametersToRemove[i];
if (parameter == null) continue;
final NonFocusableCheckBox cb =
new NonFocusableCheckBox(
RefactoringBundle.message("remove.parameter.0.no.longer.used", parameter.getName()));
removeParamsCb[i] = cb;
cb.setSelected(true);
gbConstraints.gridy++;
panel.add(cb, gbConstraints);
final int i1 = i;
cb.addChangeListener(
new ChangeListener() {
@Override
public void stateChanged(ChangeEvent e) {
myParametersToRemoveChecked[i1] = cb.isSelected();
}
});
myParametersToRemoveChecked[i] = true;
}
updateControls(removeParamsCb);
if (myCbReplaceAllOccurences != null) {
myCbReplaceAllOccurences.addItemListener(
new ItemListener() {
public void itemStateChanged(ItemEvent e) {
updateControls(removeParamsCb);
}
});
}
}
@Override
protected void canRun() throws ConfigurationException {
if (!areButtonsValid()) {
throw new ConfigurationException(
RefactoringBundle.message("refactoring.introduce.name.error"), getName());
}
}
private static boolean invoke(
final PsiMethod method,
final Project project,
@Nullable final Editor editor,
ChangeSignatureHandler initSubstisutor) {
PsiMethod newMethod =
SuperMethodWarningUtil.checkSuperMethod(method, RefactoringBundle.message("to.refactor"));
if (newMethod == null) return false;
if (!newMethod.equals(method)) {
ChangeSignatureUtil.invokeChangeSignatureOn(newMethod, project);
return true;
}
if (!CommonRefactoringUtil.checkReadOnlyStatus(project, method)) return false;
final PsiClass containingClass = method.getContainingClass();
final PsiReferenceExpression refExpr =
editor != null ? TargetElementUtil.findReferenceExpression(editor) : null;
final boolean allowDelegation = containingClass != null && !containingClass.isInterface();
final DialogWrapper dialog =
new GosuChangeSignatureDialog(
project,
new GosuMethodDescriptor((IGosuMethod) method, initSubstisutor),
allowDelegation,
refExpr,
initSubstisutor);
return dialog.showAndGet();
}
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());
}
}