diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AddTypeCastFix.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AddTypeCastFix.java index 9fc35a649504..3129f8e10699 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AddTypeCastFix.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AddTypeCastFix.java @@ -26,6 +26,7 @@ package com.intellij.codeInsight.daemon.impl.quickfix; import com.intellij.codeInsight.FileModificationService; import com.intellij.codeInsight.daemon.QuickFixBundle; +import com.intellij.codeInsight.intention.HighPriorityAction; import com.intellij.codeInspection.LocalQuickFixAndIntentionActionOnPsiElement; import com.intellij.openapi.editor.Editor; import com.intellij.openapi.project.Project; @@ -39,7 +40,7 @@ import org.jetbrains.annotations.Nullable; import static com.intellij.util.ObjectUtils.assertNotNull; -public class AddTypeCastFix extends LocalQuickFixAndIntentionActionOnPsiElement { +public class AddTypeCastFix extends LocalQuickFixAndIntentionActionOnPsiElement implements HighPriorityAction { private final PsiType myType; public AddTypeCastFix(@NotNull PsiType type, @NotNull PsiExpression expression) { diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CastMethodArgumentFix.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CastMethodArgumentFix.java index f96118bd68f3..41642d7d2bf2 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CastMethodArgumentFix.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CastMethodArgumentFix.java @@ -25,11 +25,12 @@ package com.intellij.codeInsight.daemon.impl.quickfix; import com.intellij.codeInsight.daemon.QuickFixBundle; import com.intellij.codeInsight.daemon.impl.analysis.JavaHighlightUtil; +import com.intellij.codeInsight.intention.HighPriorityAction; import com.intellij.psi.*; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; -public class CastMethodArgumentFix extends MethodArgumentFix { +public class CastMethodArgumentFix extends MethodArgumentFix implements HighPriorityAction { private CastMethodArgumentFix(PsiExpressionList list, int i, PsiType toType, final ArgumentFixerActionFactory factory) { super(list, i, toType, factory); } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInspectionBase.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInspectionBase.java index d2ddea29e9ef..c6f0f06fdb6f 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInspectionBase.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInspectionBase.java @@ -53,6 +53,7 @@ import com.intellij.util.SmartList; import com.intellij.util.containers.ContainerUtil; import com.intellij.util.containers.MultiMap; import org.jdom.Element; +import org.jetbrains.annotations.Nls; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -190,25 +191,31 @@ public class DataFlowInspectionBase extends BaseJavaBatchLocalInspectionTool { private LocalQuickFix[] createNPEFixes(PsiExpression qualifier, PsiExpression expression, boolean onTheFly) { if (qualifier == null || expression == null) return null; if (qualifier instanceof PsiMethodCallExpression) return null; - if (qualifier instanceof PsiLiteralExpression && ((PsiLiteralExpression)qualifier).getValue() == null) return null; try { final List fixes = new SmartList(); - if (PsiUtil.getLanguageLevel(qualifier).isAtLeast(LanguageLevel.JDK_1_4)) { - final Project project = qualifier.getProject(); - final PsiElementFactory elementFactory = JavaPsiFacade.getInstance(project).getElementFactory(); - final PsiBinaryExpression binary = (PsiBinaryExpression)elementFactory.createExpressionFromText("a != null", null); - binary.getLOperand().replace(qualifier); - ContainerUtil.addIfNotNull(fixes, createAssertFix(binary, expression)); + if (!(qualifier instanceof PsiLiteralExpression && ((PsiLiteralExpression)qualifier).getValue() == null)) { + if (PsiUtil.getLanguageLevel(qualifier).isAtLeast(LanguageLevel.JDK_1_4)) { + final Project project = qualifier.getProject(); + final PsiElementFactory elementFactory = JavaPsiFacade.getInstance(project).getElementFactory(); + final PsiBinaryExpression binary = (PsiBinaryExpression)elementFactory.createExpressionFromText("a != null", null); + binary.getLOperand().replace(qualifier); + ContainerUtil.addIfNotNull(fixes, createAssertFix(binary, expression)); + } + + addSurroundWithIfFix(qualifier, fixes, onTheFly); + + if (ReplaceWithTernaryOperatorFix.isAvailable(qualifier, expression)) { + fixes.add(new ReplaceWithTernaryOperatorFix(qualifier)); + } } - addSurroundWithIfFix(qualifier, fixes, onTheFly); - - if (ReplaceWithTernaryOperatorFix.isAvailable(qualifier, expression)) { - fixes.add(new ReplaceWithTernaryOperatorFix(qualifier)); + if (PsiUtil.getLanguageLevel(qualifier).isAtLeast(LanguageLevel.JDK_1_8)) { + ContainerUtil.addIfNotNull(fixes, ReplaceOptionalOfWithOfNullableFix.registerReplaceOptionalOfWithOfNullableFix(qualifier)); } - return fixes.toArray(new LocalQuickFix[fixes.size()]); + + return fixes.isEmpty() ? null : fixes.toArray(new LocalQuickFix[fixes.size()]); } catch (IncorrectOperationException e) { LOG.error(e); @@ -760,4 +767,56 @@ public class DataFlowInspectionBase extends BaseJavaBatchLocalInspectionTool { boolean normalOk; } } + + private static class ReplaceOptionalOfWithOfNullableFix implements LocalQuickFix { + + private static LocalQuickFix registerReplaceOptionalOfWithOfNullableFix(PsiExpression qualifier) { + final PsiElement argList = PsiUtil.skipParenthesizedExprUp(qualifier).getParent(); + if (argList instanceof PsiExpressionList) { + final PsiElement parent = argList.getParent(); + if (parent instanceof PsiMethodCallExpression) { + final PsiMethod method = ((PsiMethodCallExpression)parent).resolveMethod(); + if (method != null) { + final PsiClass containingClass = method.getContainingClass(); + if ("of".equals(method.getName()) && + containingClass != null && + "java.util.Optional".equals(containingClass.getQualifiedName())) { + return new ReplaceOptionalOfWithOfNullableFix(); + } + } + } + } + return null; + } + + @Nls + @NotNull + @Override + public String getName() { + return getFamilyName(); + } + + @NotNull + @Override + public String getFamilyName() { + return "Replace with '.ofNullable()'"; + } + + @Override + public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { + final PsiMethodCallExpression + methodCallExpression = PsiTreeUtil.getParentOfType(descriptor.getPsiElement(), PsiMethodCallExpression.class); + if (methodCallExpression != null) { + final PsiElement ofNullableExprName = + ((PsiMethodCallExpression)JavaPsiFacade.getElementFactory(project) + .createExpressionFromText("Optional.ofNullable(null)", null)).getMethodExpression(); + final PsiElement referenceNameElement = methodCallExpression.getMethodExpression().getReferenceNameElement(); + if (referenceNameElement != null) { + final PsiElement ofNullableNameElement = ((PsiReferenceExpression)ofNullableExprName).getReferenceNameElement(); + LOG.assertTrue(ofNullableNameElement != null); + referenceNameElement.replace(ofNullableNameElement); + } + } + } + } } diff --git a/java/java-psi-api/src/com/intellij/psi/util/RedundantCastUtil.java b/java/java-psi-api/src/com/intellij/psi/util/RedundantCastUtil.java index 2c438205c692..57ebe8bc4d5c 100644 --- a/java/java-psi-api/src/com/intellij/psi/util/RedundantCastUtil.java +++ b/java/java-psi-api/src/com/intellij/psi/util/RedundantCastUtil.java @@ -425,10 +425,14 @@ public class RedundantCastUtil { PsiTypeCastExpression castExpression = computeCastExpression.fun(newReturnExpression); PsiExpression castOperand = castExpression.getOperand(); if (castOperand == null) return; - castExpression.replace(castOperand); + castOperand = (PsiExpression)castExpression.replace(castOperand); final PsiType functionalInterfaceType = lambdaExpression.getFunctionalInterfaceType(); if (interfaceType.equals(functionalInterfaceType)) { - addToResults(returnExpression); + final PsiType interfaceReturnType = LambdaUtil.getFunctionalInterfaceReturnType(interfaceType); + final PsiType castExprType = castOperand.getType(); + if (interfaceReturnType != null && castExprType != null && interfaceReturnType.isAssignableFrom(castExprType)) { + addToResults(returnExpression); + } } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/redundantCast/PreventBadReturnTypeInReturnExpression.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/redundantCast/PreventBadReturnTypeInReturnExpression.java new file mode 100644 index 000000000000..0737fc9aaa7a --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/redundantCast/PreventBadReturnTypeInReturnExpression.java @@ -0,0 +1,7 @@ +import java.util.stream.Stream; + +class Test { + public void filterByBoolean(Stream stream) { + stream.filter(it -> (Boolean) it[0]); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/replaceWithOfNullable/afterNullable.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/replaceWithOfNullable/afterNullable.java new file mode 100644 index 000000000000..87480fe9778c --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/replaceWithOfNullable/afterNullable.java @@ -0,0 +1,6 @@ +// "Replace with '.ofNullable()'" "true" +class A{ + void test(){ + java.util.Optional.ofNullable(null); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/replaceWithOfNullable/beforeNotNull.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/replaceWithOfNullable/beforeNotNull.java new file mode 100644 index 000000000000..19c05d8c2541 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/replaceWithOfNullable/beforeNotNull.java @@ -0,0 +1,6 @@ +// "Replace with '.ofNullable()'" "false" +class A{ + void test(){ + java.util.Optional.of(11); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/replaceWithOfNullable/beforeNullable.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/replaceWithOfNullable/beforeNullable.java new file mode 100644 index 000000000000..86a82da848f4 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/replaceWithOfNullable/beforeNullable.java @@ -0,0 +1,6 @@ +// "Replace with '.ofNullable()'" "true" +class A{ + void test(){ + java.util.Optional.of(null); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/replaceWithOfNullable/beforeUnresolved.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/replaceWithOfNullable/beforeUnresolved.java new file mode 100644 index 000000000000..e3ed0d337022 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/replaceWithOfNullable/beforeUnresolved.java @@ -0,0 +1,6 @@ +// "Replace with '.ofNullable()'" "false" +class A{ + void test(){ + Optional.of(null); + } +} \ No newline at end of file diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaRedundantCastTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaRedundantCastTest.java index 78287076576e..795091df050d 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaRedundantCastTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaRedundantCastTest.java @@ -38,6 +38,8 @@ public class LambdaRedundantCastTest extends LightDaemonAnalyzerTestCase { public void testSer() { doTest(); } public void testLambdaReturnExpressions() { doTest(); } public void testLambdaReturnExpressions1() { doTest(); } + public void testPreventBadReturnTypeInReturnExpression() { doTest(); } + private void doTest() { doTest(BASE_PATH + "/" + getTestName(false) + ".java", true, false); } diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/quickFix/ReplaceWithOfNullableFixTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/quickFix/ReplaceWithOfNullableFixTest.java new file mode 100644 index 000000000000..6eef97352f65 --- /dev/null +++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/quickFix/ReplaceWithOfNullableFixTest.java @@ -0,0 +1,49 @@ +/* + * Copyright 2000-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * User: anna + * Date: 21-Mar-2008 + */ +package com.intellij.codeInsight.daemon.quickFix; + +import com.intellij.codeInspection.LocalInspectionTool; +import com.intellij.codeInspection.dataFlow.DataFlowInspection; +import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.testFramework.IdeaTestUtil; +import org.jetbrains.annotations.NotNull; + +public class ReplaceWithOfNullableFixTest extends LightQuickFixParameterizedTestCase { + @NotNull + @Override + protected LocalInspectionTool[] configureLocalInspectionTools() { + return new LocalInspectionTool[]{new DataFlowInspection()}; + } + + public void test() throws Exception { + doAllTests(); + } + + @Override + protected String getBasePath() { + return "/codeInsight/daemonCodeAnalyzer/quickFix/replaceWithOfNullable"; + } + + @Override + protected Sdk getProjectJDK() { + return IdeaTestUtil.getMockJdk18(); + } +} \ No newline at end of file diff --git a/platform/lang-impl/src/com/intellij/ide/impl/ProjectPaneSelectInTarget.java b/platform/lang-impl/src/com/intellij/ide/impl/ProjectPaneSelectInTarget.java index 59555c4dd1b0..b1331fb73ffd 100644 --- a/platform/lang-impl/src/com/intellij/ide/impl/ProjectPaneSelectInTarget.java +++ b/platform/lang-impl/src/com/intellij/ide/impl/ProjectPaneSelectInTarget.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2015 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -13,7 +13,6 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - package com.intellij.ide.impl; import com.intellij.ide.SelectInContext; @@ -33,15 +32,14 @@ public class ProjectPaneSelectInTarget extends ProjectViewSelectInTarget impleme super(project); } + @Override public String toString() { return SelectInManager.PROJECT; } @Override public boolean canSelect(PsiFileSystemItem file) { - if (!super.canSelect(file)) return false; - final VirtualFile vFile = file.getVirtualFile(); - return canSelect(vFile); + return super.canSelect(file) && canSelect(file.getVirtualFile()); } @Override @@ -49,14 +47,14 @@ public class ProjectPaneSelectInTarget extends ProjectViewSelectInTarget impleme return canSelect(context); } - private boolean canSelect(final VirtualFile vFile) { + private boolean canSelect(VirtualFile vFile) { if (vFile != null && vFile.isValid()) { - ProjectFileIndex projectFileIndex = ProjectRootManager.getInstance(myProject).getFileIndex(); - if (projectFileIndex.getModuleForFile(vFile) != null) { + ProjectFileIndex index = ProjectRootManager.getInstance(myProject).getFileIndex(); + if (index.getContentRootForFile(vFile, false) != null) { return true; } - if (projectFileIndex.isInLibraryClasses(vFile) || projectFileIndex.isInLibrarySource(vFile)) { + if (index.isInLibraryClasses(vFile) || index.isInLibrarySource(vFile)) { return true; }