From 5e380e75266b0caa1b452ca813211cd5579f8aa6 Mon Sep 17 00:00:00 2001 From: Pavel Dolgov Date: Thu, 23 Jun 2016 18:03:59 +0300 Subject: [PATCH] Java inspection: convert the intention for "Remove redundant lambda parameter types" into an INFORMATION-level inspection (IDEA-156028, IDEA-157727) --- ...dundantLambdaParameterTypeInspection.java} | 81 ++++++++----- .../Assignment.java} | 0 .../AssignmentNoParams.java} | 0 .../AssignmentNoTypes.java} | 0 .../Assignment_after.java} | 0 .../AtVarargPlace.java} | 0 .../CallNoTypeArgs.java} | 0 .../CallNoTypeArgs1.java} | 0 .../CallWithTypeArgs.java} | 0 .../CallWithTypeArgs_after.java} | 0 .../redundantLambdaParameterType/InChain.java | 7 ++ .../InChain_after.java | 7 ++ .../InferredFromOtherArgs.java} | 0 .../InferredFromOtherArgs_after.java} | 0 .../NoSelfTypeParam.java} | 0 .../NoSelfTypeParam_after.java} | 0 .../TypeParam.java} | 0 ...ndantLambdaParameterTypeIntentionTest.java | 33 ------ ...dantLambdaParameterTypeInspectionTest.java | 112 ++++++++++++++++++ .../RedundantLambdaParameterType.html | 5 + .../after.java.template | 5 - .../before.java.template | 5 - .../description.html | 5 - resources/src/META-INF/IdeaPlugin.xml | 9 +- 24 files changed, 185 insertions(+), 84 deletions(-) rename java/java-impl/src/com/intellij/{codeInsight/daemon/quickFix/RedundantLambdaParameterTypeIntention.java => codeInspection/lambda/RedundantLambdaParameterTypeInspection.java} (73%) rename java/java-tests/testData/{codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeAssignment.java => codeInspection/redundantLambdaParameterType/Assignment.java} (100%) rename java/java-tests/testData/{codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeAssignmentNoParams.java => codeInspection/redundantLambdaParameterType/AssignmentNoParams.java} (100%) rename java/java-tests/testData/{codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeAssignmentNoTypes.java => codeInspection/redundantLambdaParameterType/AssignmentNoTypes.java} (100%) rename java/java-tests/testData/{codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterAssignment.java => codeInspection/redundantLambdaParameterType/Assignment_after.java} (100%) rename java/java-tests/testData/{codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeAtVarargPlace.java => codeInspection/redundantLambdaParameterType/AtVarargPlace.java} (100%) rename java/java-tests/testData/{codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeCallNoTypeArgs.java => codeInspection/redundantLambdaParameterType/CallNoTypeArgs.java} (100%) rename java/java-tests/testData/{codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeCallNoTypeArgs1.java => codeInspection/redundantLambdaParameterType/CallNoTypeArgs1.java} (100%) rename java/java-tests/testData/{codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeCallWithTypeArgs.java => codeInspection/redundantLambdaParameterType/CallWithTypeArgs.java} (100%) rename java/java-tests/testData/{codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterCallWithTypeArgs.java => codeInspection/redundantLambdaParameterType/CallWithTypeArgs_after.java} (100%) create mode 100644 java/java-tests/testData/codeInspection/redundantLambdaParameterType/InChain.java create mode 100644 java/java-tests/testData/codeInspection/redundantLambdaParameterType/InChain_after.java rename java/java-tests/testData/{codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeInferredFromOtherArgs.java => codeInspection/redundantLambdaParameterType/InferredFromOtherArgs.java} (100%) rename java/java-tests/testData/{codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterInferredFromOtherArgs.java => codeInspection/redundantLambdaParameterType/InferredFromOtherArgs_after.java} (100%) rename java/java-tests/testData/{codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeNoSelfTypeParam.java => codeInspection/redundantLambdaParameterType/NoSelfTypeParam.java} (100%) rename java/java-tests/testData/{codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterNoSelfTypeParam.java => codeInspection/redundantLambdaParameterType/NoSelfTypeParam_after.java} (100%) rename java/java-tests/testData/{codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeTypeParam.java => codeInspection/redundantLambdaParameterType/TypeParam.java} (100%) delete mode 100644 java/java-tests/testSrc/com/intellij/codeInsight/daemon/quickFix/RedundantLambdaParameterTypeIntentionTest.java create mode 100644 java/java-tests/testSrc/com/intellij/codeInspection/RedundantLambdaParameterTypeInspectionTest.java create mode 100644 resources-en/src/inspectionDescriptions/RedundantLambdaParameterType.html delete mode 100644 resources-en/src/intentionDescriptions/RedundantLambdaParameterTypeIntention/after.java.template delete mode 100644 resources-en/src/intentionDescriptions/RedundantLambdaParameterTypeIntention/before.java.template delete mode 100644 resources-en/src/intentionDescriptions/RedundantLambdaParameterTypeIntention/description.html diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/quickFix/RedundantLambdaParameterTypeIntention.java b/java/java-impl/src/com/intellij/codeInspection/lambda/RedundantLambdaParameterTypeInspection.java similarity index 73% rename from java/java-impl/src/com/intellij/codeInsight/daemon/quickFix/RedundantLambdaParameterTypeIntention.java rename to java/java-impl/src/com/intellij/codeInspection/lambda/RedundantLambdaParameterTypeInspection.java index 38eacc30395a..4e2445fbaee9 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/quickFix/RedundantLambdaParameterTypeIntention.java +++ b/java/java-impl/src/com/intellij/codeInspection/lambda/RedundantLambdaParameterTypeInspection.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2012 JetBrains s.r.o. + * Copyright 2000-2016 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,44 +13,43 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.intellij.codeInsight.daemon.quickFix; +package com.intellij.codeInspection.lambda; -import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction; +import com.intellij.codeInspection.BaseJavaBatchLocalInspectionTool; +import com.intellij.codeInspection.LocalQuickFix; +import com.intellij.codeInspection.ProblemDescriptor; +import com.intellij.codeInspection.ProblemsHolder; import com.intellij.openapi.diagnostic.Logger; -import com.intellij.openapi.editor.Editor; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; import com.intellij.psi.impl.source.resolve.DefaultParameterTypeInferencePolicy; import com.intellij.psi.infos.MethodCandidateInfo; -import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtil; -import com.intellij.util.Function; -import com.intellij.util.IncorrectOperationException; +import org.jetbrains.annotations.Nls; import org.jetbrains.annotations.NotNull; /** * User: anna */ -public class RedundantLambdaParameterTypeIntention extends PsiElementBaseIntentionAction { - public static final Logger LOG = Logger.getInstance("#" + RedundantLambdaParameterTypeIntention.class.getName()); +public class RedundantLambdaParameterTypeInspection extends BaseJavaBatchLocalInspectionTool { + public static final Logger LOG = Logger.getInstance("#" + RedundantLambdaParameterTypeInspection.class.getName()); @NotNull @Override - public String getFamilyName() { - return "Remove redundant types"; + public PsiElementVisitor buildVisitor(@NotNull ProblemsHolder holder, boolean isOnTheFly) { + return new JavaElementVisitor() { + @Override + public void visitParameterList(PsiParameterList parameterList) { + super.visitParameterList(parameterList); + if (isApplicable(parameterList)) { + holder.registerProblem(parameterList, "Remove redundant types", new LambdaParametersFix()); + } + } + }; } - @NotNull - @Override - public String getText() { - return getFamilyName(); - } - - @Override - public boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement element) { - final PsiParameterList parameterList = PsiTreeUtil.getParentOfType(element, PsiParameterList.class); - if (parameterList == null) return false; + private static boolean isApplicable(@NotNull PsiParameterList parameterList) { final PsiElement parent = parameterList.getParent(); if (!(parent instanceof PsiLambdaExpression)) return false; final PsiLambdaExpression expression = (PsiLambdaExpression)parent; @@ -73,9 +72,9 @@ public class RedundantLambdaParameterTypeIntention extends PsiElementBaseIntenti final PsiTypeParameter[] typeParameters = method.getTypeParameters(); final PsiExpression[] arguments = ((PsiExpressionList)lambdaParent).getExpressions(); - final JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance(project); + final JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance(parameterList.getProject()); arguments[idx] = javaPsiFacade.getElementFactory().createExpressionFromText( - "(" + StringUtil.join(expression.getParameterList().getParameters(), parameter -> parameter.getName(), ", ") + ") -> {}", expression); + "(" + StringUtil.join(expression.getParameterList().getParameters(), PsiParameter::getName, ", ") + ") -> {}", expression); final PsiParameter[] methodParams = method.getParameterList().getParameters(); final PsiSubstitutor substitutor = javaPsiFacade.getResolveHelper() .inferTypeArguments(typeParameters, methodParams, arguments, ((MethodCandidateInfo)resolveResult).getSiteSubstitutor(), @@ -85,8 +84,7 @@ public class RedundantLambdaParameterTypeIntention extends PsiElementBaseIntenti final PsiType psiType = substitutor.substitute(parameter); if (psiType == null || dependsOnTypeParams(psiType, expression, parameter)) return false; } - - + final PsiType paramType; if (idx < methodParams.length) { paramType = methodParams[idx].getType(); @@ -107,12 +105,6 @@ public class RedundantLambdaParameterTypeIntention extends PsiElementBaseIntenti return false; } - @Override - public void invoke(@NotNull Project project, Editor editor, @NotNull PsiElement element) throws IncorrectOperationException { - final PsiLambdaExpression lambdaExpression = PsiTreeUtil.getParentOfType(element, PsiLambdaExpression.class); - removeTypes(lambdaExpression); - } - private static void removeTypes(PsiLambdaExpression lambdaExpression) { if (lambdaExpression != null) { final PsiParameter[] parameters = lambdaExpression.getParameterList().getParameters(); @@ -121,7 +113,7 @@ public class RedundantLambdaParameterTypeIntention extends PsiElementBaseIntenti text = parameters[0].getName(); } else { - text = "(" + StringUtil.join(parameters, parameter -> parameter.getName(), ", ") + ")"; + text = "(" + StringUtil.join(parameters, PsiParameter::getName, ", ") + ")"; } final PsiLambdaExpression expression = (PsiLambdaExpression)JavaPsiFacade.getElementFactory(lambdaExpression.getProject()) .createExpressionFromText(text + "->{}", lambdaExpression); @@ -135,4 +127,29 @@ public class RedundantLambdaParameterTypeIntention extends PsiElementBaseIntenti return LambdaUtil.depends(type, new LambdaUtil.TypeParamsChecker(expr, PsiUtil .resolveGenericsClassInType(LambdaUtil.getFunctionalInterfaceType(expr, false)).getElement()), param2Check); } + + private static class LambdaParametersFix implements LocalQuickFix { + @Nls + @NotNull + @Override + public String getName() { + return getFamilyName(); + } + + @Nls + @NotNull + @Override + public String getFamilyName() { + return "Remove redundant types"; + } + + @Override + public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { + final PsiElement element = descriptor.getPsiElement(); + final PsiElement parent = element.getParent(); + if (parent instanceof PsiLambdaExpression) { + removeTypes((PsiLambdaExpression)parent); + } + } + } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeAssignment.java b/java/java-tests/testData/codeInspection/redundantLambdaParameterType/Assignment.java similarity index 100% rename from java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeAssignment.java rename to java/java-tests/testData/codeInspection/redundantLambdaParameterType/Assignment.java diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeAssignmentNoParams.java b/java/java-tests/testData/codeInspection/redundantLambdaParameterType/AssignmentNoParams.java similarity index 100% rename from java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeAssignmentNoParams.java rename to java/java-tests/testData/codeInspection/redundantLambdaParameterType/AssignmentNoParams.java diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeAssignmentNoTypes.java b/java/java-tests/testData/codeInspection/redundantLambdaParameterType/AssignmentNoTypes.java similarity index 100% rename from java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeAssignmentNoTypes.java rename to java/java-tests/testData/codeInspection/redundantLambdaParameterType/AssignmentNoTypes.java diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterAssignment.java b/java/java-tests/testData/codeInspection/redundantLambdaParameterType/Assignment_after.java similarity index 100% rename from java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterAssignment.java rename to java/java-tests/testData/codeInspection/redundantLambdaParameterType/Assignment_after.java diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeAtVarargPlace.java b/java/java-tests/testData/codeInspection/redundantLambdaParameterType/AtVarargPlace.java similarity index 100% rename from java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeAtVarargPlace.java rename to java/java-tests/testData/codeInspection/redundantLambdaParameterType/AtVarargPlace.java diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeCallNoTypeArgs.java b/java/java-tests/testData/codeInspection/redundantLambdaParameterType/CallNoTypeArgs.java similarity index 100% rename from java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeCallNoTypeArgs.java rename to java/java-tests/testData/codeInspection/redundantLambdaParameterType/CallNoTypeArgs.java diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeCallNoTypeArgs1.java b/java/java-tests/testData/codeInspection/redundantLambdaParameterType/CallNoTypeArgs1.java similarity index 100% rename from java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeCallNoTypeArgs1.java rename to java/java-tests/testData/codeInspection/redundantLambdaParameterType/CallNoTypeArgs1.java diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeCallWithTypeArgs.java b/java/java-tests/testData/codeInspection/redundantLambdaParameterType/CallWithTypeArgs.java similarity index 100% rename from java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeCallWithTypeArgs.java rename to java/java-tests/testData/codeInspection/redundantLambdaParameterType/CallWithTypeArgs.java diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterCallWithTypeArgs.java b/java/java-tests/testData/codeInspection/redundantLambdaParameterType/CallWithTypeArgs_after.java similarity index 100% rename from java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterCallWithTypeArgs.java rename to java/java-tests/testData/codeInspection/redundantLambdaParameterType/CallWithTypeArgs_after.java diff --git a/java/java-tests/testData/codeInspection/redundantLambdaParameterType/InChain.java b/java/java-tests/testData/codeInspection/redundantLambdaParameterType/InChain.java new file mode 100644 index 000000000000..7262e3bbca40 --- /dev/null +++ b/java/java-tests/testData/codeInspection/redundantLambdaParameterType/InChain.java @@ -0,0 +1,7 @@ +import java.util.stream.Stream; + +class InChain { + public static void main(String[] args) { + Stream.of("a").map((String s) -> s + "1").forEach(System.out::println); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInspection/redundantLambdaParameterType/InChain_after.java b/java/java-tests/testData/codeInspection/redundantLambdaParameterType/InChain_after.java new file mode 100644 index 000000000000..857e423db1eb --- /dev/null +++ b/java/java-tests/testData/codeInspection/redundantLambdaParameterType/InChain_after.java @@ -0,0 +1,7 @@ +import java.util.stream.Stream; + +class InChain { + public static void main(String[] args) { + Stream.of("a").map(s -> s + "1").forEach(System.out::println); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeInferredFromOtherArgs.java b/java/java-tests/testData/codeInspection/redundantLambdaParameterType/InferredFromOtherArgs.java similarity index 100% rename from java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeInferredFromOtherArgs.java rename to java/java-tests/testData/codeInspection/redundantLambdaParameterType/InferredFromOtherArgs.java diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterInferredFromOtherArgs.java b/java/java-tests/testData/codeInspection/redundantLambdaParameterType/InferredFromOtherArgs_after.java similarity index 100% rename from java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterInferredFromOtherArgs.java rename to java/java-tests/testData/codeInspection/redundantLambdaParameterType/InferredFromOtherArgs_after.java diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeNoSelfTypeParam.java b/java/java-tests/testData/codeInspection/redundantLambdaParameterType/NoSelfTypeParam.java similarity index 100% rename from java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeNoSelfTypeParam.java rename to java/java-tests/testData/codeInspection/redundantLambdaParameterType/NoSelfTypeParam.java diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterNoSelfTypeParam.java b/java/java-tests/testData/codeInspection/redundantLambdaParameterType/NoSelfTypeParam_after.java similarity index 100% rename from java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterNoSelfTypeParam.java rename to java/java-tests/testData/codeInspection/redundantLambdaParameterType/NoSelfTypeParam_after.java diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeTypeParam.java b/java/java-tests/testData/codeInspection/redundantLambdaParameterType/TypeParam.java similarity index 100% rename from java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeTypeParam.java rename to java/java-tests/testData/codeInspection/redundantLambdaParameterType/TypeParam.java diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/quickFix/RedundantLambdaParameterTypeIntentionTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/quickFix/RedundantLambdaParameterTypeIntentionTest.java deleted file mode 100644 index 4f85962f0a62..000000000000 --- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/quickFix/RedundantLambdaParameterTypeIntentionTest.java +++ /dev/null @@ -1,33 +0,0 @@ -/* - * Copyright 2000-2012 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. - */ -package com.intellij.codeInsight.daemon.quickFix; - -import com.intellij.openapi.projectRoots.Sdk; -import com.intellij.testFramework.IdeaTestUtil; - -public class RedundantLambdaParameterTypeIntentionTest extends LightQuickFixParameterizedTestCase { - public void test() throws Exception { doAllTests(); } - - @Override - protected String getBasePath() { - return "/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType"; - } - - @Override - protected Sdk getProjectJDK() { - return IdeaTestUtil.getMockJdk18(); - } -} \ No newline at end of file diff --git a/java/java-tests/testSrc/com/intellij/codeInspection/RedundantLambdaParameterTypeInspectionTest.java b/java/java-tests/testSrc/com/intellij/codeInspection/RedundantLambdaParameterTypeInspectionTest.java new file mode 100644 index 000000000000..3e610fcbcf04 --- /dev/null +++ b/java/java-tests/testSrc/com/intellij/codeInspection/RedundantLambdaParameterTypeInspectionTest.java @@ -0,0 +1,112 @@ +/* + * Copyright 2000-2016 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:public void testwww() {}.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. + */ +package com.intellij.codeInspection; + +import com.intellij.JavaTestUtil; +import com.intellij.codeInsight.intention.IntentionAction; +import com.intellij.codeInspection.lambda.RedundantLambdaParameterTypeInspection; +import com.intellij.idea.Bombed; +import com.intellij.openapi.roots.ModuleRootModificationUtil; +import com.intellij.testFramework.IdeaTestUtil; +import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase; + +import java.util.Calendar; +import java.util.List; + +public class RedundantLambdaParameterTypeInspectionTest extends LightCodeInsightFixtureTestCase { + private RedundantLambdaParameterTypeInspection myInspection = new RedundantLambdaParameterTypeInspection(); + private String myIntentionName = "Remove redundant types"; + + @Override + protected String getBasePath() { + return JavaTestUtil.getRelativeJavaTestDataPath() + "/codeInspection/redundantLambdaParameterType"; + } + + @Override + protected void setUp() throws Exception { + super.setUp(); + ModuleRootModificationUtil.setModuleSdk(myModule, IdeaTestUtil.getMockJdk18()); + myFixture.enableInspections(myInspection); + } + + @Override + protected void tearDown() throws Exception { + try { + myFixture.disableInspections(myInspection); + } + finally { + super.tearDown(); + } + } + + public void testAssignment() { + doTest(); + } + + public void testAssignmentNoParams() { + assertIntentionNotAvailable(); + } + + public void testAssignmentNoTypes() { + assertIntentionNotAvailable(); + } + + public void testAtVarargPlace() { + assertIntentionNotAvailable(); + } + + public void testCallNoTypeArgs() { + assertIntentionNotAvailable(); + } + + public void testCallNoTypeArgs1() { + assertIntentionNotAvailable(); + } + + public void testCallWithTypeArgs() { + doTest(); + } + + public void testInferredFromOtherArgs() { + doTest(); + } + + public void testNoSelfTypeParam() { + doTest(); + } + + public void testTypeParam() { + assertIntentionNotAvailable(); + } + + @Bombed(month = Calendar.AUGUST, day = 1, user = "Pavel Dolgov") + public void testInChain() { + doTest(); + } + + private void doTest() { + myFixture.configureByFiles(getTestName(false) + ".java"); + final IntentionAction singleIntention = myFixture.findSingleIntention(myIntentionName); + myFixture.launchAction(singleIntention); + myFixture.checkResultByFile(getTestName(false) + ".java", getTestName(false) + "_after.java", true); + } + + private void assertIntentionNotAvailable() { + myFixture.configureByFiles(getTestName(false) + ".java"); + final List intentionActions = myFixture.filterAvailableIntentions(myIntentionName); + assertEmpty(myIntentionName + " is not expected", intentionActions); + } +} \ No newline at end of file diff --git a/resources-en/src/inspectionDescriptions/RedundantLambdaParameterType.html b/resources-en/src/inspectionDescriptions/RedundantLambdaParameterType.html new file mode 100644 index 000000000000..ea49461e2613 --- /dev/null +++ b/resources-en/src/inspectionDescriptions/RedundantLambdaParameterType.html @@ -0,0 +1,5 @@ + + +This inspection removes lambda formal parameter types when they can be inferred from context. + + \ No newline at end of file diff --git a/resources-en/src/intentionDescriptions/RedundantLambdaParameterTypeIntention/after.java.template b/resources-en/src/intentionDescriptions/RedundantLambdaParameterTypeIntention/after.java.template deleted file mode 100644 index 925e26bf3039..000000000000 --- a/resources-en/src/intentionDescriptions/RedundantLambdaParameterTypeIntention/after.java.template +++ /dev/null @@ -1,5 +0,0 @@ -class X { - { - Comparable c = o -> 0; - } -} \ No newline at end of file diff --git a/resources-en/src/intentionDescriptions/RedundantLambdaParameterTypeIntention/before.java.template b/resources-en/src/intentionDescriptions/RedundantLambdaParameterTypeIntention/before.java.template deleted file mode 100644 index 84da2abb9213..000000000000 --- a/resources-en/src/intentionDescriptions/RedundantLambdaParameterTypeIntention/before.java.template +++ /dev/null @@ -1,5 +0,0 @@ -class X { - { - Comparable c = (String o) -> 0; - } -} \ No newline at end of file diff --git a/resources-en/src/intentionDescriptions/RedundantLambdaParameterTypeIntention/description.html b/resources-en/src/intentionDescriptions/RedundantLambdaParameterTypeIntention/description.html deleted file mode 100644 index 7e47e9314b11..000000000000 --- a/resources-en/src/intentionDescriptions/RedundantLambdaParameterTypeIntention/description.html +++ /dev/null @@ -1,5 +0,0 @@ - - -This intention removes lambda formal parameter types when they can be inferred from context. - - \ No newline at end of file diff --git a/resources/src/META-INF/IdeaPlugin.xml b/resources/src/META-INF/IdeaPlugin.xml index 29201b0565b2..4be169a82fed 100644 --- a/resources/src/META-INF/IdeaPlugin.xml +++ b/resources/src/META-INF/IdeaPlugin.xml @@ -800,11 +800,12 @@ groupKey="group.names.declaration.redundancy" enabledByDefault="true" level="WARNING" implementationClass="com.intellij.codeInspection.SimplifyStreamApiCallChainsInspection" displayName="Simplify stream API call chains"/> + - - com.intellij.codeInsight.daemon.quickFix.RedundantLambdaParameterTypeIntention - Java/Declaration - com.intellij.codeInsight.intention.impl.SplitIfAction Java/Control Flow