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 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(); } }
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); }
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(); }
private void invokeOnElements( @NotNull final Project project, @NotNull final Editor editor, @NotNull PsiFile file, @NotNull PsiElement[] elements) { if (elements.length == 0) { String message = RefactoringBundle.getCannotRefactorMessage( RefactoringBundle.message( "selected.block.should.represent.a.set.of.statements.or.an.expression")); CommonRefactoringUtil.showErrorHint( project, editor, message, ExtractMethodObjectProcessor.REFACTORING_NAME, HelpID.EXTRACT_METHOD_OBJECT); return; } final ExtractMethodObjectProcessor processor = new ExtractMethodObjectProcessor(project, editor, elements, ""); final ExtractMethodObjectProcessor.MyExtractMethodProcessor extractProcessor = processor.getExtractProcessor(); try { if (!extractProcessor.prepare()) return; } catch (PrepareFailedException e) { CommonRefactoringUtil.showErrorHint( project, editor, e.getMessage(), ExtractMethodObjectProcessor.REFACTORING_NAME, HelpID.EXTRACT_METHOD_OBJECT); ExtractMethodHandler.highlightPrepareError(e, file, editor, project); return; } if (!CommonRefactoringUtil.checkReadOnlyStatus( project, extractProcessor.getTargetClass().getContainingFile())) return; if (extractProcessor.showDialog()) { run(project, editor, processor, extractProcessor); } }
private static void invokeOnElement(Project project, Editor editor, PsiElement element) { if (element instanceof PsiMethod) { final ChangeSignatureGestureDetector detector = ChangeSignatureGestureDetector.getInstance(project); final PsiIdentifier nameIdentifier = ((PsiMethod) element).getNameIdentifier(); if (nameIdentifier != null && detector.isChangeSignatureAvailable(nameIdentifier)) { detector.changeSignature(element.getContainingFile(), false); return; } invoke((PsiMethod) element, project, editor); } else if (element instanceof PsiClass) { invoke((PsiClass) element, editor); } else { String message = RefactoringBundle.getCannotRefactorMessage( RefactoringBundle.message("error.wrong.caret.position.method.or.class.name")); CommonRefactoringUtil.showErrorHint( project, editor, message, REFACTORING_NAME, HelpID.CHANGE_SIGNATURE); } }
@Override public void invoke( @NotNull final Project project, final Editor editor, PsiFile file, DataContext dataContext) { final int offset = editor.getCaretModel().getOffset(); final PsiElement element = file.findElementAt(offset); final PsiMember member = PsiTreeUtil.getParentOfType(element, PsiMember.class); final String cannotRefactorMessage = getCannotRefactorMessage(member); if (cannotRefactorMessage != null) { String message = RefactoringBundle.getCannotRefactorMessage(cannotRefactorMessage); showErrorMessage(message, project, editor); return; } final AnalysisScope scope = new AnalysisScope(file); final Module module = ModuleUtilCore.findModuleForPsiElement(file); final BaseAnalysisActionDialog dlg = new BaseAnalysisActionDialog( RefactoringBundle.message( "replace.method.duplicates.scope.chooser.title", REFACTORING_NAME), RefactoringBundle.message("replace.method.duplicates.scope.chooser.message"), project, scope, module != null ? module.getName() : null, false, AnalysisUIOptions.getInstance(project), element); if (dlg.showAndGet()) { ProgressManager.getInstance() .run( new Task.Backgroundable(project, "Locate duplicates", true) { @Override public void run(@NotNull ProgressIndicator indicator) { indicator.setIndeterminate(true); invokeOnScope( project, member, dlg.getScope(AnalysisUIOptions.getInstance(project), scope, project, module)); } }); } }
public void invoke( @NotNull Project project, Editor editor, PsiFile file, DataContext dataContext) { editor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE); int offset = editor.getCaretModel().getOffset(); PsiElement element = file.findElementAt(offset); while (true) { if (element == null || element instanceof PsiFile) { String message = RefactoringBundle.getCannotRefactorMessage( RefactoringBundle.message("error.wrong.caret.position.class")); CommonRefactoringUtil.showErrorHint( project, editor, message, REFACTORING_NAME, HelpID.EXTRACT_SUPERCLASS); return; } if (element instanceof PsiClass && !(element instanceof PsiAnonymousClass)) { invoke(project, new PsiElement[] {element}, dataContext); return; } element = element.getParent(); } }
private static boolean 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 false; } if (!CommonRefactoringUtil.checkReadOnlyStatus(project, aClass)) return false; ChangeClassSignatureDialog dialog = new ChangeClassSignatureDialog(aClass, true); // if (!ApplicationManager.getApplication().isUnitTestMode()){ return dialog.showAndGet(); // }else { // dialog.showAndGetOk() // } }
@Nullable public static JetChangeSignatureDialog createDialog( @NotNull PsiElement element, PsiElement context, Project project, Editor editor) { if (!CommonRefactoringUtil.checkReadOnlyStatus(project, element)) return null; BindingContext bindingContext = AnalyzerFacadeWithCache.analyzeFileWithCache((JetFile) element.getContainingFile()) .getBindingContext(); DeclarationDescriptor descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, element); if (descriptor instanceof ClassDescriptor) { descriptor = ((ClassDescriptor) descriptor).getUnsubstitutedPrimaryConstructor(); } if (descriptor instanceof FunctionDescriptorImpl) { for (ValueParameterDescriptor parameter : ((FunctionDescriptor) descriptor).getValueParameters()) { if (parameter.getVarargElementType() != null) { String message = JetRefactoringBundle.message("error.cant.refactor.vararg.functions"); CommonRefactoringUtil.showErrorHint( project, editor, message, REFACTORING_NAME, HelpID.CHANGE_SIGNATURE); return null; } } return new JetChangeSignatureDialog( project, new JetFunctionPlatformDescriptorImpl((FunctionDescriptor) descriptor, element), context); } else { String message = RefactoringBundle.getCannotRefactorMessage( JetRefactoringBundle.message( "error.wrong.caret.position.function.or.constructor.name")); CommonRefactoringUtil.showErrorHint( project, editor, message, REFACTORING_NAME, HelpID.CHANGE_SIGNATURE); return null; } }
public void invoke( @NotNull final Project project, final Editor editor, final PsiFile file, DataContext dataContext) { myIncludingFile = file; if (!editor.getSelectionModel().hasSelection()) { String message = RefactoringBundle.getCannotRefactorMessage(RefactoringBundle.message("no.selection")); CommonRefactoringUtil.showErrorHint(project, editor, message, getRefactoringName(), HELP_ID); return; } final int start = editor.getSelectionModel().getSelectionStart(); final int end = editor.getSelectionModel().getSelectionEnd(); final Pair<T, T> children = findPairToExtract(start, end); if (children == null) { String message = RefactoringBundle.getCannotRefactorMessage( RefactoringBundle.message("selection.does.not.form.a.fragment.for.extraction")); CommonRefactoringUtil.showErrorHint(project, editor, message, getRefactoringName(), HELP_ID); return; } if (!verifyChildRange(children.getFirst(), children.getSecond())) { String message = RefactoringBundle.getCannotRefactorMessage( RefactoringBundle.message("cannot.extract.selected.elements.into.include.file")); CommonRefactoringUtil.showErrorHint(project, editor, message, getRefactoringName(), HELP_ID); return; } final FileType fileType = getFileType(getLanguageForExtract(children.getFirst())); if (!(fileType instanceof LanguageFileType)) { String message = RefactoringBundle.message( "the.language.for.selected.elements.has.no.associated.file.type"); CommonRefactoringUtil.showErrorHint(project, editor, message, getRefactoringName(), HELP_ID); return; } if (!CommonRefactoringUtil.checkReadOnlyStatus(project, file)) return; ExtractIncludeDialog dialog = createDialog(file.getContainingDirectory(), getExtractExtension(fileType, children.first)); dialog.show(); if (dialog.getExitCode() == DialogWrapper.OK_EXIT_CODE) { final PsiDirectory targetDirectory = dialog.getTargetDirectory(); LOG.assertTrue(targetDirectory != null); final String targetfileName = dialog.getTargetFileName(); CommandProcessor.getInstance() .executeCommand( project, new Runnable() { public void run() { ApplicationManager.getApplication() .runWriteAction( new Runnable() { public void run() { try { final List<IncludeDuplicate<T>> duplicates = new ArrayList<IncludeDuplicate<T>>(); final T first = children.getFirst(); final T second = children.getSecond(); PsiEquivalenceUtil.findChildRangeDuplicates( first, second, file, new PairConsumer<PsiElement, PsiElement>() { public void consume( final PsiElement start, final PsiElement end) { duplicates.add(new IncludeDuplicate<T>((T) start, (T) end)); } }); final String includePath = processPrimaryFragment( first, second, targetDirectory, targetfileName, file); editor .getCaretModel() .moveToOffset(first.getTextRange().getStartOffset()); ApplicationManager.getApplication() .invokeLater( new Runnable() { public void run() { replaceDuplicates( includePath, duplicates, editor, project); } }); } catch (IncorrectOperationException e) { CommonRefactoringUtil.showErrorMessage( getRefactoringName(), e.getMessage(), null, project); } editor.getSelectionModel().removeSelection(); } }); } }, getRefactoringName(), null); } }
public void invoke( @NotNull final Project project, @NotNull PsiElement[] elements, DataContext dataContext) { if (elements.length != 1) return; myProject = project; mySubclass = (PsiClass) elements[0]; if (!CommonRefactoringUtil.checkReadOnlyStatus(project, mySubclass)) return; Editor editor = dataContext != null ? PlatformDataKeys.EDITOR.getData(dataContext) : null; if (mySubclass.isInterface()) { String message = RefactoringBundle.getCannotRefactorMessage( RefactoringBundle.message("superclass.cannot.be.extracted.from.an.interface")); CommonRefactoringUtil.showErrorHint( project, editor, message, REFACTORING_NAME, HelpID.EXTRACT_SUPERCLASS); return; } if (mySubclass.isEnum()) { String message = RefactoringBundle.getCannotRefactorMessage( RefactoringBundle.message("superclass.cannot.be.extracted.from.an.enum")); CommonRefactoringUtil.showErrorHint( project, editor, message, REFACTORING_NAME, HelpID.EXTRACT_SUPERCLASS); return; } final List<MemberInfo> memberInfos = MemberInfo.extractClassMembers( mySubclass, new MemberInfo.Filter<PsiMember>() { public boolean includeMember(PsiMember element) { return true; } }, false); final ExtractSuperclassDialog dialog = new ExtractSuperclassDialog( project, mySubclass, memberInfos, ExtractSuperclassHandler.this); dialog.show(); if (!dialog.isOK() || !dialog.isExtractSuperclass()) return; CommandProcessor.getInstance() .executeCommand( myProject, new Runnable() { public void run() { final Runnable action = new Runnable() { public void run() { doRefactoring(project, mySubclass, dialog); } }; ApplicationManager.getApplication().runWriteAction(action); } }, REFACTORING_NAME, null); }
protected Settings showRefactoringDialog( Project project, final Editor editor, PsiClass parentClass, PsiExpression expr, PsiType type, PsiExpression[] occurrences, PsiElement anchorElement, PsiElement anchorElementIfAll) { final PsiMethod containingMethod = PsiTreeUtil.getParentOfType(expr != null ? expr : anchorElement, PsiMethod.class); PsiLocalVariable localVariable = null; if (expr instanceof PsiReferenceExpression) { PsiElement ref = ((PsiReferenceExpression) expr).resolve(); if (ref instanceof PsiLocalVariable) { localVariable = (PsiLocalVariable) ref; } } else if (anchorElement instanceof PsiLocalVariable) { localVariable = (PsiLocalVariable) anchorElement; } String enteredName = null; boolean replaceAllOccurrences = true; final AbstractInplaceIntroducer activeIntroducer = AbstractInplaceIntroducer.getActiveIntroducer(editor); if (activeIntroducer != null) { activeIntroducer.stopIntroduce(editor); expr = (PsiExpression) activeIntroducer.getExpr(); localVariable = (PsiLocalVariable) activeIntroducer.getLocalVariable(); occurrences = (PsiExpression[]) activeIntroducer.getOccurrences(); enteredName = activeIntroducer.getInputName(); replaceAllOccurrences = activeIntroducer.isReplaceAllOccurrences(); type = ((InplaceIntroduceConstantPopup) activeIntroducer).getType(); } for (PsiExpression occurrence : occurrences) { if (RefactoringUtil.isAssignmentLHS(occurrence)) { String message = RefactoringBundle.getCannotRefactorMessage("Selected expression is used for write"); CommonRefactoringUtil.showErrorHint( project, editor, message, REFACTORING_NAME, getHelpID()); highlightError(project, editor, occurrence); return null; } } if (localVariable == null) { final PsiElement errorElement = isStaticFinalInitializer(expr); if (errorElement != null) { String message = RefactoringBundle.getCannotRefactorMessage( RefactoringBundle.message("selected.expression.cannot.be.a.constant.initializer")); CommonRefactoringUtil.showErrorHint( project, editor, message, REFACTORING_NAME, getHelpID()); highlightError(project, editor, errorElement); return null; } } else { final PsiExpression initializer = localVariable.getInitializer(); if (initializer == null) { String message = RefactoringBundle.getCannotRefactorMessage( RefactoringBundle.message( "variable.does.not.have.an.initializer", localVariable.getName())); CommonRefactoringUtil.showErrorHint( project, editor, message, REFACTORING_NAME, getHelpID()); return null; } final PsiElement errorElement = isStaticFinalInitializer(initializer); if (errorElement != null) { String message = RefactoringBundle.getCannotRefactorMessage( RefactoringBundle.message( "initializer.for.variable.cannot.be.a.constant.initializer", localVariable.getName())); CommonRefactoringUtil.showErrorHint( project, editor, message, REFACTORING_NAME, getHelpID()); highlightError(project, editor, errorElement); return null; } } final TypeSelectorManagerImpl typeSelectorManager = new TypeSelectorManagerImpl(project, type, containingMethod, expr, occurrences); if (editor != null && editor.getSettings().isVariableInplaceRenameEnabled() && (expr == null || expr.isPhysical()) && activeIntroducer == null) { myInplaceIntroduceConstantPopup = new InplaceIntroduceConstantPopup( project, editor, parentClass, expr, localVariable, occurrences, typeSelectorManager, anchorElement, anchorElementIfAll, expr != null ? createOccurrenceManager(expr, parentClass) : null); if (myInplaceIntroduceConstantPopup.startInplaceIntroduceTemplate()) { return null; } } final IntroduceConstantDialog dialog = new IntroduceConstantDialog( project, parentClass, expr, localVariable, localVariable != null, occurrences, getParentClass(), typeSelectorManager, enteredName); dialog.setReplaceAllOccurrences(replaceAllOccurrences); if (!dialog.showAndGet()) { if (occurrences.length > 1) { WindowManager.getInstance() .getStatusBar(project) .setInfo(RefactoringBundle.message("press.escape.to.remove.the.highlighting")); } return null; } return new Settings( dialog.getEnteredName(), expr, occurrences, dialog.isReplaceAllOccurrences(), true, true, InitializationPlace.IN_FIELD_DECLARATION, dialog.getFieldVisibility(), localVariable, dialog.getSelectedType(), dialog.isDeleteVariable(), dialog.getDestinationClass(), dialog.isAnnotateAsNonNls(), dialog.introduceEnumConstant()); }