static void addExceptionsToThrowsList( @NotNull final Project project, @NotNull final PsiMethod targetMethod, @NotNull final Set<PsiClassType> unhandledExceptions) { final PsiMethod[] superMethods = getSuperMethods(targetMethod); boolean hasSuperMethodsWithoutExceptions = hasSuperMethodsWithoutExceptions(superMethods, unhandledExceptions); final boolean processSuperMethods; if (hasSuperMethodsWithoutExceptions && superMethods.length > 0) { int result = ApplicationManager.getApplication().isUnitTestMode() ? Messages.YES : Messages.showYesNoCancelDialog( QuickFixBundle.message( "add.exception.to.throws.inherited.method.warning.text", targetMethod.getName()), QuickFixBundle.message("method.is.inherited.warning.title"), Messages.getQuestionIcon()); if (result == Messages.YES) { processSuperMethods = true; } else if (result == Messages.NO) { processSuperMethods = false; } else { return; } } else { processSuperMethods = false; } ApplicationManager.getApplication() .runWriteAction( () -> { if (!FileModificationService.getInstance() .prepareFileForWrite(targetMethod.getContainingFile())) return; if (processSuperMethods) { for (PsiMethod superMethod : superMethods) { if (!FileModificationService.getInstance() .prepareFileForWrite(superMethod.getContainingFile())) return; } } try { processMethod(project, targetMethod, unhandledExceptions); if (processSuperMethods) { for (PsiMethod superMethod : superMethods) { processMethod(project, superMethod, unhandledExceptions); } } } catch (IncorrectOperationException e) { LOG.error(e); } }); }
public static void createProperty( @NotNull final Project project, @NotNull final PsiElement psiElement, @NotNull final Collection<PropertiesFile> selectedPropertiesFiles, @NotNull final String key, @NotNull final String value) { for (PropertiesFile selectedFile : selectedPropertiesFiles) { if (!FileModificationService.getInstance() .prepareFileForWrite(selectedFile.getContainingFile())) return; } UndoUtil.markPsiFileForUndo(psiElement.getContainingFile()); ApplicationManager.getApplication() .runWriteAction( new Runnable() { public void run() { CommandProcessor.getInstance() .executeCommand( project, new Runnable() { public void run() { try { I18nUtil.createProperty(project, selectedPropertiesFiles, key, value); } catch (IncorrectOperationException e) { LOG.error(e); } } }, CodeInsightBundle.message("quickfix.i18n.command.name"), project); } }); }
@Override public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException { if (!FileModificationService.getInstance().prepareFileForWrite(file)) return; PsiExpression expression = getExpressionToSimplify(editor, file); SimplifyBooleanExpressionFix.simplifyExpression(expression); }
@Override public void invoke(@NotNull final Project project, final Editor editor, PsiFile file) { if (!FileModificationService.getInstance().prepareFileForWrite(file)) return; ApplicationManager.getApplication() .runWriteAction( () -> { final List<T> methodsToImport = getMembersToImport(false); if (methodsToImport.isEmpty()) return; createQuestionAction(methodsToImport, project, editor).execute(); }); }
@Override public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { if (!FileModificationService.getInstance() .preparePsiElementForWrite(descriptor.getPsiElement())) return; PsiElement castTypeElement = descriptor.getPsiElement(); PsiTypeCastExpression cast = castTypeElement == null ? null : (PsiTypeCastExpression) castTypeElement.getParent(); if (cast != null) { RedundantCastUtil.removeCast(cast); } }
@Override public void invoke(@NotNull Project project, Editor editor, @NotNull PsiElement element) throws IncorrectOperationException { try { if (!FileModificationService.getInstance().preparePsiElementForWrite(element)) return; final PsiJavaToken token = (PsiJavaToken) element; final PsiPolyadicExpression expression = SplitConditionUtil.findCondition(element, true, false); final PsiLambdaExpression lambdaExpression = PsiTreeUtil.getParentOfType(expression, PsiLambdaExpression.class); LOG.assertTrue(lambdaExpression != null); final String lambdaParameterName = lambdaExpression.getParameterList().getParameters()[0].getName(); final PsiMethodCallExpression methodCallExpression = PsiTreeUtil.getParentOfType(expression, PsiMethodCallExpression.class); LOG.assertTrue(methodCallExpression != null, expression); PsiExpression lOperand = getLOperands(expression, token); PsiExpression rOperand = getROperands(expression, token); final Collection<PsiComment> comments = PsiTreeUtil.findChildrenOfType(expression, PsiComment.class); final PsiMethodCallExpression chainedCall = (PsiMethodCallExpression) JavaPsiFacade.getElementFactory(project) .createExpressionFromText( "a.filter(" + lambdaParameterName + " -> x)", expression); final PsiExpression argExpression = chainedCall.getArgumentList().getExpressions()[0]; final PsiElement rReplaced = ((PsiLambdaExpression) argExpression).getBody().replace(rOperand); final PsiExpression compoundArg = methodCallExpression.getArgumentList().getExpressions()[0]; final int separatorOffset = token.getTextOffset(); for (PsiComment comment : comments) { if (comment.getTextOffset() < separatorOffset) { compoundArg.getParent().add(comment); } else { rReplaced.getParent().add(comment); } } ((PsiLambdaExpression) compoundArg).getBody().replace(lOperand); chainedCall.getMethodExpression().getQualifierExpression().replace(methodCallExpression); methodCallExpression.replace(chainedCall); } catch (IncorrectOperationException e) { LOG.error(e); } }
@Override public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { final PsiTypeElement typeElement = PsiTreeUtil.getParentOfType(descriptor.getPsiElement(), PsiTypeElement.class); if (!FileModificationService.getInstance().preparePsiElementForWrite(typeElement)) return; final PsiMethodReferenceExpression expression = PsiTreeUtil.getParentOfType(typeElement, PsiMethodReferenceExpression.class); if (expression != null) { expression.replace(createMethodReference(expression, typeElement)); } }
@Override public void invoke(@NotNull Project project, Editor editor, @NotNull PsiElement element) { if (prepareForWriting() && !FileModificationService.getInstance().preparePsiElementsForWrite(element)) { return; } final PsiElement matchingElement = findMatchingElement(element, editor); if (matchingElement == null) { return; } processIntention(editor, matchingElement); }
@Override public void invoke( @NotNull Project project, @NotNull PsiFile file, Editor editor, @NotNull PsiElement startElement, @NotNull PsiElement endElement) { final PsiMethod myMethod = (PsiMethod) startElement; if (!FileModificationService.getInstance().prepareFileForWrite(myMethod.getContainingFile())) return; final PsiType myReturnType = myReturnTypePointer.getType(); if (myReturnType == null) return; if (myFixWholeHierarchy) { final PsiMethod superMethod = myMethod.findDeepestSuperMethod(); final PsiType superReturnType = superMethod == null ? null : superMethod.getReturnType(); if (superReturnType != null && !Comparing.equal(myReturnType, superReturnType) && !changeClassTypeArgument( myMethod, project, superReturnType, superMethod.getContainingClass(), editor, myReturnType)) { return; } } final List<PsiMethod> affectedMethods = changeReturnType(myMethod, myReturnType); PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory(); PsiReturnStatement statementToSelect = null; if (!PsiType.VOID.equals(myReturnType)) { final ReturnStatementAdder adder = new ReturnStatementAdder(factory, myReturnType); for (PsiMethod affectedMethod : affectedMethods) { PsiReturnStatement statement = adder.addReturnForMethod(file, affectedMethod); if (statement != null && affectedMethod == myMethod) { statementToSelect = statement; } } } if (statementToSelect != null) { Editor editorForMethod = getEditorForMethod(myMethod, project, editor, statementToSelect.getContainingFile()); if (editorForMethod != null) { selectReturnValueInEditor(statementToSelect, editorForMethod); } } }
@Override public void invoke(@NotNull final Project project, Editor editor, PsiFile file) { if (!FileModificationService.getInstance().prepareFileForWrite(file)) return; PsiDocumentManager.getInstance(project).commitAllDocuments(); final List<PsiClassType> exceptions = new ArrayList<PsiClassType>(); final PsiMethod targetMethod = collectExceptions(exceptions); if (targetMethod == null) return; Set<PsiClassType> unhandledExceptions = new THashSet<PsiClassType>(exceptions); addExceptionsToThrowsList(project, targetMethod, unhandledExceptions); }
private void invokeFix( final RefEntity element, final CommonProblemDescriptor descriptor, final int idx) { final QuickFix[] fixes = descriptor.getFixes(); if (fixes != null && fixes.length > idx && fixes[idx] != null) { if (element instanceof RefElement) { PsiElement psiElement = ((RefElement) element).getElement(); if (psiElement != null && psiElement.isValid()) { if (!FileModificationService.getInstance().preparePsiElementForWrite(psiElement)) return; performFix(element, descriptor, idx, fixes[idx]); } } else { performFix(element, descriptor, idx, fixes[idx]); } } }
@Override public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { final PsiReferenceParameterList typeArgumentList = (PsiReferenceParameterList) descriptor.getPsiElement(); if (!FileModificationService.getInstance().preparePsiElementForWrite(typeArgumentList)) return; try { final PsiMethodCallExpression expr = (PsiMethodCallExpression) JavaPsiFacade.getInstance(project) .getElementFactory() .createExpressionFromText("foo()", null); typeArgumentList.replace(expr.getTypeArgumentList()); } catch (IncorrectOperationException e) { LOG.error(e); } }
@Override public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { final PsiElement element = descriptor.getPsiElement(); if (element != null) { if (!FileModificationService.getInstance().preparePsiElementForWrite(element)) return; final PsiLambdaExpression lambdaExpression = PsiTreeUtil.getParentOfType(element, PsiLambdaExpression.class); if (lambdaExpression != null) { final PsiElement body = lambdaExpression.getBody(); if (body != null) { PsiExpression expression = LambdaUtil.extractSingleExpressionFromBody(body); if (expression != null) { body.replace(expression); } } } } }
@Override public void invoke(@NotNull Project project, Editor editor, @NotNull PsiElement element) throws IncorrectOperationException { if (!FileModificationService.getInstance().preparePsiElementsForWrite(element)) return; final XmlAttribute attr = (XmlAttribute) element.getParent(); final String name = attr.getName(); final XmlAttributeDescriptor descriptor = attr.getDescriptor(); LOG.assertTrue(descriptor != null); String value = attr.getValue(); final PsiElement declaration = descriptor.getDeclaration(); if (declaration instanceof PsiField) { final PsiType fieldType = ((PsiField) declaration).getType(); final PsiType itemType = JavaGenericsUtil.getCollectionItemType(fieldType, declaration.getResolveScope()); if (itemType != null) { final String typeNode = itemType.getPresentableText(); JavaFxPsiUtil.insertImportWhenNeeded( (XmlFile) attr.getContainingFile(), typeNode, itemType.getCanonicalText()); final String[] vals = value.split(","); value = StringUtil.join( vals, new Function<String, String>() { @Override public String fun(String s) { return "<" + typeNode + " " + FxmlConstants.FX_VALUE + "=\"" + s.trim() + "\"/>"; } }, "\n"); } } final XmlTag childTag = XmlElementFactory.getInstance(project) .createTagFromText("<" + name + ">" + value + "</" + name + ">"); attr.getParent().add(childTag); attr.delete(); }
public void run() { final PsiFile psiFile = myField.getContainingFile(); if (psiFile == null) return; if (!FileModificationService.getInstance().preparePsiElementForWrite(psiFile)) return; ApplicationManager.getApplication() .runWriteAction( new Runnable() { public void run() { CommandProcessor.getInstance() .executeCommand( myField.getProject(), new Runnable() { public void run() { try { final PsiManager manager = myField.getManager(); myField .getTypeElement() .replace( JavaPsiFacade.getInstance(manager.getProject()) .getElementFactory() .createTypeElement(myNewType)); } catch (final IncorrectOperationException e) { ApplicationManager.getApplication() .invokeLater( new Runnable() { public void run() { Messages.showErrorDialog( myEditor, UIDesignerBundle.message( "error.cannot.change.field.type", myField.getName(), e.getMessage()), CommonBundle.getErrorTitle()); } }); } } }, getName(), null); } }); }
@Override public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { if (!FileModificationService.getInstance() .preparePsiElementForWrite(descriptor.getPsiElement())) return; final PsiElement psiElement = descriptor.getPsiElement(); if (psiElement instanceof PsiInstanceOfExpression) { try { final PsiExpression compareToNull = JavaPsiFacade.getInstance(psiElement.getProject()) .getElementFactory() .createExpressionFromText( ((PsiInstanceOfExpression) psiElement).getOperand().getText() + " != null", psiElement.getParent()); psiElement.replace(compareToNull); } catch (IncorrectOperationException e) { LOG.error(e); } } }
public static void chooseColor( JComponent editorComponent, PsiElement element, String caption, boolean startInWriteAction) { final XmlAttributeValue literal = PsiTreeUtil.getParentOfType(element, XmlAttributeValue.class, false); if (literal == null) return; final String text = StringUtil.unquoteString(literal.getValue()); Color oldColor; try { oldColor = Color.decode(text); } catch (NumberFormatException e) { oldColor = JBColor.GRAY; } Color color = ColorChooser.chooseColor(editorComponent, caption, oldColor, true); if (color == null) return; if (!Comparing.equal(color, oldColor)) { if (!FileModificationService.getInstance().preparePsiElementForWrite(element)) return; final String newText = "#" + ColorUtil.toHex(color); final PsiManager manager = literal.getManager(); final XmlAttribute newAttribute = XmlElementFactory.getInstance(manager.getProject()).createXmlAttribute("name", newText); final Runnable replaceRunnable = new Runnable() { @Override public void run() { final XmlAttributeValue valueElement = newAttribute.getValueElement(); assert valueElement != null; literal.replace(valueElement); } }; if (startInWriteAction) { new WriteCommandAction(element.getProject(), caption) { @Override protected void run(@NotNull Result result) throws Throwable { replaceRunnable.run(); } }.execute(); } else { replaceRunnable.run(); } } }
@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); } } }
@Override public void invoke(@NotNull Project project, Editor editor, PsiFile file) { if (!FileModificationService.getInstance().preparePsiElementsForWrite(myClass, myVariable)) return; try { switch (myFixType) { case MAKE_FINAL: makeFinal(); break; case MAKE_ARRAY: makeArray(); break; case COPY_TO_FINAL: copyToFinal(); break; } } catch (IncorrectOperationException e) { LOG.error(e); } finally { getVariablesToFix().clear(); } }
@Override public void invoke(@NotNull final Project project, Editor editor, final PsiFile file) { if (!FileModificationService.getInstance().prepareFileForWrite(file)) return; final PsiMethod method = SuperMethodWarningUtil.checkSuperMethod( myTargetMethod, RefactoringBundle.message("to.refactor")); if (method == null) return; myNewParametersInfo = getNewParametersInfo(myExpressions, myTargetMethod, mySubstitutor); final List<ParameterInfoImpl> parameterInfos = performChange( project, editor, file, method, myMinUsagesNumberToShowDialog, myNewParametersInfo, myChangeAllUsages, false); if (parameterInfos != null) { myNewParametersInfo = parameterInfos.toArray(new ParameterInfoImpl[parameterInfos.size()]); } }
public void finishLookup(char completionChar, @Nullable final LookupElement item) { //noinspection deprecation,unchecked if (item == null || item instanceof EmptyLookupItem || item.getObject() instanceof DeferredUserLookupValue && item.as(LookupItem.CLASS_CONDITION_KEY) != null && !((DeferredUserLookupValue) item.getObject()) .handleUserSelection(item.as(LookupItem.CLASS_CONDITION_KEY), myProject)) { doHide(false, true); fireItemSelected(null, completionChar); return; } if (myDisposed) { // DeferredUserLookupValue could close us in any way return; } final PsiFile file = getPsiFile(); boolean writableOk = file == null || FileModificationService.getInstance().prepareFileForWrite(file); if (myDisposed) { // ensureFilesWritable could close us by showing a dialog return; } if (!writableOk) { doHide(false, true); fireItemSelected(null, completionChar); return; } final String prefix = itemPattern(item); boolean plainMatch = ContainerUtil.or( item.getAllLookupStrings(), new Condition<String>() { @Override public boolean value(String s) { return StringUtil.containsIgnoreCase(s, prefix); } }); if (!plainMatch) { FeatureUsageTracker.getInstance() .triggerFeatureUsed(CodeCompletionFeatures.EDITING_COMPLETION_CAMEL_HUMPS); } myFinishing = true; ApplicationManager.getApplication() .runWriteAction( new Runnable() { public void run() { myEditor.getDocument().startGuardedBlockChecking(); try { insertLookupString(item, getPrefixLength(item)); } finally { myEditor.getDocument().stopGuardedBlockChecking(); } } }); if (myDisposed) { // any document listeners could close us return; } doHide(false, true); fireItemSelected(item, completionChar); }
@Override public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException { if (!FileModificationService.getInstance().prepareFileForWrite(file)) return; myAnnotation.delete(); }
@Override public void invoke(@NotNull final Project project, final Editor editor, final PsiFile file) throws IncorrectOperationException { if (!FileModificationService.getInstance().prepareFileForWrite(file)) return; PsiMethod[] constructors = myClass.getConstructors(); if (constructors.length == 0) { final AddDefaultConstructorFix defaultConstructorFix = new AddDefaultConstructorFix(myClass); ApplicationManager.getApplication() .runWriteAction( new Runnable() { @Override public void run() { defaultConstructorFix.invoke(project, editor, file); } }); constructors = myClass.getConstructors(); } Arrays.sort( constructors, new Comparator<PsiMethod>() { @Override public int compare(PsiMethod c1, PsiMethod c2) { final PsiMethod cc1 = RefactoringUtil.getChainedConstructor(c1); final PsiMethod cc2 = RefactoringUtil.getChainedConstructor(c2); if (cc1 == c2) return 1; if (cc2 == c1) return -1; if (cc1 == null) { return cc2 == null ? 0 : compare(c1, cc2); } else { return cc2 == null ? compare(cc1, c2) : compare(cc1, cc2); } } }); final ArrayList<PsiMethod> constrs = filterConstructorsIfFieldAlreadyAssigned(constructors, getField()); if (constrs.size() > 1) { final PsiMethodMember[] members = new PsiMethodMember[constrs.size()]; int i = 0; for (PsiMethod constructor : constrs) { members[i++] = new PsiMethodMember(constructor); } final List<PsiMethodMember> elements; if (ApplicationManager.getApplication().isUnitTestMode()) { elements = Arrays.asList(members); } else { final MemberChooser<PsiMethodMember> chooser = new MemberChooser<PsiMethodMember>(members, false, true, project); chooser.setTitle("Choose constructors to add parameter to"); chooser.show(); elements = chooser.getSelectedElements(); if (elements == null) return; } for (PsiMethodMember member : elements) { if (!addParameterToConstructor( project, file, editor, member.getElement(), new PsiField[] {getField()})) break; } } else if (!constrs.isEmpty()) { final Collection<SmartPsiElementPointer<PsiField>> fieldsToFix = getFieldsToFix(); try { final PsiMethod constructor = constrs.get(0); final LinkedHashSet<PsiField> fields = new LinkedHashSet<PsiField>(); getFieldsToFix().add(myField); for (SmartPsiElementPointer<PsiField> elementPointer : fieldsToFix) { final PsiField field = elementPointer.getElement(); if (field != null && isAvailable(field) && filterConstructorsIfFieldAlreadyAssigned(new PsiMethod[] {constructor}, field) .contains(constructor)) { fields.add(field); } } if (constrs.size() == constructors.length && fields.size() > 1 && !ApplicationManager.getApplication().isUnitTestMode()) { PsiFieldMember[] members = new PsiFieldMember[fields.size()]; int i = 0; for (PsiField field : fields) { members[i++] = new PsiFieldMember(field); } MemberChooser<PsiElementClassMember> chooser = new MemberChooser<PsiElementClassMember>(members, false, true, project); chooser.setTitle("Choose Fields to Generate Constructor Parameters for"); chooser.show(); if (chooser.getExitCode() != DialogWrapper.OK_EXIT_CODE) return; final List<PsiElementClassMember> selectedElements = chooser.getSelectedElements(); if (selectedElements == null) return; fields.clear(); for (PsiElementClassMember member : selectedElements) { fields.add((PsiField) member.getElement()); } } addParameterToConstructor( project, file, editor, constructor, constrs.size() == constructors.length ? fields.toArray(new PsiField[fields.size()]) : new PsiField[] {getField()}); } finally { fieldsToFix.clear(); } } }
@Override public void invoke(@NotNull Project project, Editor editor, PsiFile file) { if (!FileModificationService.getInstance().prepareFileForWrite(myVariable.getContainingFile())) return; removeVariableAndReferencingStatements(editor); }
public static void invoke( final Project project, PsiFile file, final Editor editor, PsiElement element) { if (!FileModificationService.getInstance().prepareFileForWrite(file)) return; final PsiJavaCodeReferenceElement refExpr = (PsiJavaCodeReferenceElement) element.getParent(); final PsiClass aClass = (PsiClass) refExpr.resolve(); if (aClass == null) { return; } final PsiClass containingClass = PsiUtil.getTopLevelClass(refExpr); if (aClass != containingClass) { PsiImportList importList = ((PsiJavaFile) file).getImportList(); if (importList == null) { return; } boolean alreadyImported = false; for (PsiImportStaticStatement statement : importList.getImportStaticStatements()) { if (!statement.isOnDemand()) continue; PsiClass staticResolve = statement.resolveTargetClass(); if (aClass == staticResolve) { alreadyImported = true; break; } } if (!alreadyImported) { PsiImportStaticStatement importStaticStatement = JavaPsiFacade.getInstance(file.getProject()) .getElementFactory() .createImportStaticStatement(aClass, "*"); importList.add(importStaticStatement); } } List<PsiFile> roots = file.getViewProvider().getAllFiles(); for (final PsiFile root : roots) { PsiElement copy = root.copy(); final PsiManager manager = root.getManager(); final TIntArrayList expressionToDequalifyOffsets = new TIntArrayList(); copy.accept( new JavaRecursiveElementWalkingVisitor() { int delta; @Override public void visitReferenceElement(PsiJavaCodeReferenceElement expression) { if (isParameterizedReference(expression)) return; PsiElement qualifierExpression = expression.getQualifier(); if (qualifierExpression instanceof PsiJavaCodeReferenceElement && ((PsiJavaCodeReferenceElement) qualifierExpression).isReferenceTo(aClass)) { try { PsiElement resolved = expression.resolve(); int end = expression.getTextRange().getEndOffset(); qualifierExpression.delete(); delta += end - expression.getTextRange().getEndOffset(); PsiElement after = expression.resolve(); if (manager.areElementsEquivalent(after, resolved)) { expressionToDequalifyOffsets.add( expression.getTextRange().getStartOffset() + delta); } } catch (IncorrectOperationException e) { LOG.error(e); } } super.visitElement(expression); } }); expressionToDequalifyOffsets.forEachDescending( new TIntProcedure() { @Override public boolean execute(int offset) { PsiJavaCodeReferenceElement expression = PsiTreeUtil.findElementOfClassAtOffset( root, offset, PsiJavaCodeReferenceElement.class, false); if (expression == null) { return false; } PsiElement qualifierExpression = expression.getQualifier(); if (qualifierExpression instanceof PsiJavaCodeReferenceElement && ((PsiJavaCodeReferenceElement) qualifierExpression).isReferenceTo(aClass)) { qualifierExpression.delete(); if (editor != null) { HighlightManager.getInstance(project) .addRangeHighlight( editor, expression.getTextRange().getStartOffset(), expression.getTextRange().getEndOffset(), EditorColorsManager.getInstance() .getGlobalScheme() .getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES), false, null); } } return true; } }); } }
@Override public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { final PsiForeachStatement foreachStatement = PsiTreeUtil.getParentOfType(descriptor.getPsiElement(), PsiForeachStatement.class); if (foreachStatement != null) { if (!FileModificationService.getInstance().preparePsiElementForWrite(foreachStatement)) return; PsiStatement body = foreachStatement.getBody(); final PsiExpression iteratedValue = foreachStatement.getIteratedValue(); if (body != null && iteratedValue != null) { restoreComments(foreachStatement, body); final PsiParameter parameter = foreachStatement.getIterationParameter(); final PsiIfStatement ifStmt = extractIfStatement(body); StringBuilder buffer = new StringBuilder(getIteratedValueText(iteratedValue)); if (ifStmt != null) { final PsiStatement thenBranch = ifStmt.getThenBranch(); LOG.assertTrue(thenBranch != null); buffer.append(".stream()"); buffer.append(createFiltersChainText(body, parameter, ifStmt)); body = thenBranch; } buffer.append(".").append(getForEachMethodName()).append("("); final String functionalExpressionText = createForEachFunctionalExpressionText(project, body, parameter); final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project); PsiExpressionStatement callStatement = (PsiExpressionStatement) elementFactory.createStatementFromText( buffer.toString() + functionalExpressionText + ");", foreachStatement); callStatement = (PsiExpressionStatement) foreachStatement.replace(callStatement); final PsiExpressionList argumentList = ((PsiCallExpression) callStatement.getExpression()).getArgumentList(); LOG.assertTrue(argumentList != null, callStatement.getText()); final PsiExpression[] expressions = argumentList.getExpressions(); LOG.assertTrue(expressions.length == 1); if (expressions[0] instanceof PsiFunctionalExpression && ((PsiFunctionalExpression) expressions[0]).getFunctionalInterfaceType() == null) { callStatement = (PsiExpressionStatement) callStatement.replace( elementFactory.createStatementFromText( buffer.toString() + "(" + parameter.getText() + ") -> " + wrapInBlock(body) + ");", callStatement)); } simplifyRedundantCast(callStatement); CodeStyleManager.getInstance(project) .reformat( JavaCodeStyleManager.getInstance(project).shortenClassReferences(callStatement)); } } }
@Override public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { final PsiForeachStatement foreachStatement = PsiTreeUtil.getParentOfType(descriptor.getPsiElement(), PsiForeachStatement.class); if (foreachStatement != null) { if (!FileModificationService.getInstance().preparePsiElementForWrite(foreachStatement)) return; final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project); PsiStatement body = foreachStatement.getBody(); final PsiExpression iteratedValue = foreachStatement.getIteratedValue(); if (body != null && iteratedValue != null) { final PsiParameter parameter = foreachStatement.getIterationParameter(); final PsiIfStatement ifStatement = extractIfStatement(body); final PsiMethodCallExpression methodCallExpression = extractAddCall(body, ifStatement); if (methodCallExpression == null) return; if (isAddAllCall(foreachStatement, body)) { restoreComments(foreachStatement, body); final PsiExpression qualifierExpression = methodCallExpression.getMethodExpression().getQualifierExpression(); final String qualifierText = qualifierExpression != null ? qualifierExpression.getText() : ""; final String callText = StringUtil.getQualifiedName( qualifierText, "addAll(" + getIteratedValueText(iteratedValue) + ");"); PsiElement result = foreachStatement.replace( elementFactory.createStatementFromText(callText, foreachStatement)); reformatWhenNeeded(project, result); return; } final StringBuilder builder = new StringBuilder(getIteratedValueText(iteratedValue) + ".stream()"); builder.append(createFiltersChainText(body, parameter, ifStatement)); builder.append( createMapperFunctionalExpressionText( parameter, methodCallExpression.getArgumentList().getExpressions()[0])); builder.append(".collect(java.util.stream.Collectors."); PsiElement result = null; try { final PsiExpression qualifierExpression = methodCallExpression.getMethodExpression().getQualifierExpression(); if (qualifierExpression instanceof PsiReferenceExpression) { final PsiElement resolve = ((PsiReferenceExpression) qualifierExpression).resolve(); if (resolve instanceof PsiVariable) { if (resolve instanceof PsiLocalVariable && foreachStatement.equals( PsiTreeUtil.skipSiblingsForward( resolve.getParent(), PsiWhiteSpace.class))) { final PsiExpression initializer = ((PsiVariable) resolve).getInitializer(); if (initializer instanceof PsiNewExpression) { final PsiExpressionList argumentList = ((PsiNewExpression) initializer).getArgumentList(); if (argumentList != null && argumentList.getExpressions().length == 0) { restoreComments(foreachStatement, body); final String callText = builder.toString() + createInitializerReplacementText( ((PsiVariable) resolve).getType(), initializer) + ")"; result = initializer.replace( elementFactory.createExpressionFromText(callText, null)); simplifyRedundantCast(result); foreachStatement.delete(); return; } } } } } restoreComments(foreachStatement, body); final String qualifierText = qualifierExpression != null ? qualifierExpression.getText() : ""; final String callText = StringUtil.getQualifiedName( qualifierText, "addAll(" + builder.toString() + "toList()));"); result = foreachStatement.replace( elementFactory.createStatementFromText(callText, foreachStatement)); simplifyRedundantCast(result); } finally { reformatWhenNeeded(project, result); } } } }
public static List<ParameterInfoImpl> performChange( final Project project, final Editor editor, final PsiFile file, final PsiMethod method, final int minUsagesNumber, final ParameterInfoImpl[] newParametersInfo, final boolean changeAllUsages, final boolean allowDelegation) { if (!FileModificationService.getInstance().prepareFileForWrite(method.getContainingFile())) return null; final FindUsagesManager findUsagesManager = ((FindManagerImpl) FindManager.getInstance(project)).getFindUsagesManager(); final FindUsagesHandler handler = findUsagesManager.getFindUsagesHandler(method, false); if (handler == null) return null; // on failure or cancel (e.g. cancel of super methods dialog) final JavaMethodFindUsagesOptions options = new JavaMethodFindUsagesOptions(project); options.isImplementingMethods = true; options.isOverridingMethods = true; options.isUsages = true; options.isSearchForTextOccurrences = false; final int[] usagesFound = new int[1]; Runnable runnable = () -> { Processor<UsageInfo> processor = t -> ++usagesFound[0] < minUsagesNumber; handler.processElementUsages(method, processor, options); }; String progressTitle = QuickFixBundle.message("searching.for.usages.progress.title"); if (!ProgressManager.getInstance() .runProcessWithProgressSynchronously(runnable, progressTitle, true, project)) return null; if (ApplicationManager.getApplication().isUnitTestMode() || usagesFound[0] < minUsagesNumber) { ChangeSignatureProcessor processor = new ChangeSignatureProcessor( project, method, false, null, method.getName(), method.getReturnType(), newParametersInfo) { @Override @NotNull protected UsageInfo[] findUsages() { return changeAllUsages ? super.findUsages() : UsageInfo.EMPTY_ARRAY; } @Override protected void performRefactoring(@NotNull UsageInfo[] usages) { CommandProcessor.getInstance().setCurrentCommandName(getCommandName()); super.performRefactoring(usages); } }; processor.run(); ApplicationManager.getApplication().runWriteAction(() -> UndoUtil.markPsiFileForUndo(file)); return Arrays.asList(newParametersInfo); } else { final List<ParameterInfoImpl> parameterInfos = newParametersInfo != null ? new ArrayList<ParameterInfoImpl>(Arrays.asList(newParametersInfo)) : new ArrayList<ParameterInfoImpl>(); final PsiReferenceExpression refExpr = JavaTargetElementEvaluator.findReferenceExpression(editor); JavaChangeSignatureDialog dialog = JavaChangeSignatureDialog.createAndPreselectNew( project, method, parameterInfos, allowDelegation, refExpr); dialog.setParameterInfos(parameterInfos); dialog.show(); return dialog.isOK() ? dialog.getParameters() : null; } }