From 5c24e5a3c6c3cbdea890eedd2f917b8f2051ce58 Mon Sep 17 00:00:00 2001 From: anna Date: Tue, 15 Feb 2011 14:50:02 +0100 Subject: [PATCH] redundant unchecked warning inspection --- ...ntUncheckedSuppressWarningsInspection.java | 223 ++++++++++++++++++ .../ex/StandardInspectionToolsProvider.java | 3 +- .../redundantUncheckedVarargs/after1.java | 13 + .../redundantUncheckedVarargs/after2.java | 14 ++ .../redundantUncheckedVarargs/after4.java | 14 ++ .../redundantUncheckedVarargs/after5.java | 14 ++ .../redundantUncheckedVarargs/after6.java | 14 ++ .../redundantUncheckedVarargs/after9.java | 15 ++ .../redundantUncheckedVarargs/before1.java | 14 ++ .../redundantUncheckedVarargs/before2.java | 14 ++ .../redundantUncheckedVarargs/before3.java | 15 ++ .../redundantUncheckedVarargs/before4.java | 15 ++ .../redundantUncheckedVarargs/before5.java | 15 ++ .../redundantUncheckedVarargs/before6.java | 15 ++ .../redundantUncheckedVarargs/before7.java | 15 ++ .../redundantUncheckedVarargs/before8.java | 15 ++ .../redundantUncheckedVarargs/before9.java | 15 ++ ...moveRedundantUncheckedSuppressionTest.java | 46 ++++ .../RedundantUncheckedSuppress.html | 6 + 19 files changed, 494 insertions(+), 1 deletion(-) create mode 100644 java/java-impl/src/com/intellij/codeInspection/RedundantUncheckedSuppressWarningsInspection.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after1.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after4.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after5.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after6.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after9.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before1.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before3.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before4.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before5.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before6.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before7.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before8.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before9.java create mode 100644 java/java-tests/testSrc/com/intellij/codeInsight/daemon/quickFix/RemoveRedundantUncheckedSuppressionTest.java create mode 100644 resources-en/src/inspectionDescriptions/RedundantUncheckedSuppress.html diff --git a/java/java-impl/src/com/intellij/codeInspection/RedundantUncheckedSuppressWarningsInspection.java b/java/java-impl/src/com/intellij/codeInspection/RedundantUncheckedSuppressWarningsInspection.java new file mode 100644 index 000000000000..8b6575560df6 --- /dev/null +++ b/java/java-impl/src/com/intellij/codeInspection/RedundantUncheckedSuppressWarningsInspection.java @@ -0,0 +1,223 @@ +/* + * Copyright 2000-2011 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.codeInspection; + +import com.intellij.codeInsight.AnnotationUtil; +import com.intellij.codeInsight.daemon.GroupNames; +import com.intellij.codeInsight.daemon.impl.analysis.GenericsHighlightUtil; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.Comparing; +import com.intellij.openapi.util.TextRange; +import com.intellij.openapi.util.text.StringUtil; +import com.intellij.pom.java.LanguageLevel; +import com.intellij.psi.*; +import com.intellij.psi.util.PsiTreeUtil; +import com.intellij.psi.util.PsiUtil; +import com.intellij.util.Function; +import org.jetbrains.annotations.Nls; +import org.jetbrains.annotations.NonNls; +import org.jetbrains.annotations.NotNull; + +import java.util.*; +import java.util.regex.Matcher; + +/** + * User: anna + * Date: 2/14/11 + */ +public class RedundantUncheckedSuppressWarningsInspection extends BaseJavaLocalInspectionTool { + @Nls + @NotNull + @Override + public String getGroupDisplayName() { + return GroupNames.LANGUAGE_LEVEL_SPECIFIC_GROUP_NAME; + } + @Nls + @NotNull + @Override + public String getDisplayName() { + return "Redundant unchecked warning suppressed"; + } + @NotNull + @Override + public String getShortName() { + return "RedundantUncheckedSuppress"; + } + @Override + public boolean isEnabledByDefault() { + return true; + } + + @NotNull + @Override + public PsiElementVisitor buildVisitor(@NotNull final ProblemsHolder holder, boolean isOnTheFly) { + return new JavaElementVisitor() { + @Override + public void visitReferenceExpression(PsiReferenceExpression expression) { + } + + @Override + public void visitComment(PsiComment comment) { + super.visitComment(comment); + if (!PsiUtil.getLanguageLevel(comment).isAtLeast(LanguageLevel.JDK_1_7)) return; + final HashSet tools2Suppress = new HashSet(); + collectCommentSuppresses(comment, tools2Suppress); + if (tools2Suppress.contains(RemoveUncheckedWarningFix.UNCHECKED)) { + final PsiElement statement = PsiTreeUtil.skipSiblingsForward(comment, PsiWhiteSpace.class); + if (statement instanceof PsiStatement) { + checkIfSafeToRemoveWarning(comment, statement, holder); + } + } + } + + @Override + public void visitAnnotation(PsiAnnotation annotation) { + super.visitAnnotation(annotation); + if (!PsiUtil.getLanguageLevel(annotation).isAtLeast(LanguageLevel.JDK_1_7)) return; + if (Comparing.strEqual(annotation.getQualifiedName(), SuppressWarnings.class.getName())) { + final PsiAnnotationOwner owner = annotation.getOwner(); + if (owner instanceof PsiModifierList) { + final PsiModifierListOwner modifierListOwner = PsiTreeUtil.getParentOfType(((PsiModifierList)owner), PsiModifierListOwner.class); + if (modifierListOwner != null) { + final Collection suppressedIds = + SuppressManager.getInstance().getInspectionIdsSuppressedInAnnotation(modifierListOwner); + if (suppressedIds.contains(RemoveUncheckedWarningFix.UNCHECKED)) { + checkIfSafeToRemoveWarning(annotation, modifierListOwner, holder); + } + } + } + } + } + }; + } + + private static void checkIfSafeToRemoveWarning(PsiElement suppressElement, PsiElement placeToCheckWarningsIn, ProblemsHolder holder) { + final HashSet warningsElements = new HashSet(); + collectUncheckedWarnings(placeToCheckWarningsIn, true, warningsElements); + for (Iterator iterator = warningsElements.iterator(); iterator.hasNext(); ) { + PsiReferenceExpression element = iterator.next(); + final PsiElement resolve = element.resolve(); + if (resolve instanceof PsiMethod && AnnotationUtil.isAnnotated((PsiMethod)resolve, "java.lang.SafeVarargs", false)) { + iterator.remove(); + } + } + if (warningsElements.isEmpty()) { + final int uncheckedIdx = suppressElement.getText().indexOf(RemoveUncheckedWarningFix.UNCHECKED); + holder.registerProblem(suppressElement, + uncheckedIdx > -1 ? new TextRange(uncheckedIdx, uncheckedIdx + RemoveUncheckedWarningFix.UNCHECKED.length()) : null, + "Redundant suppression", new RemoveUncheckedWarningFix()); + } + } + + public static void collectUncheckedWarnings(final PsiElement place, final boolean ignoreSuppressed, final Collection warningsElements) { + place.accept(new JavaRecursiveElementVisitor() { + @Override + public void visitReferenceExpression(PsiReferenceExpression expression) { + super.visitReferenceExpression(expression); + if (!ignoreSuppressed && SuppressManager.getInstance().isSuppressedFor(expression, RemoveUncheckedWarningFix.UNCHECKED)) return; + + final PsiElement resolve = expression.resolve(); + if (resolve instanceof PsiMethod) { + final PsiMethod psiMethod = (PsiMethod)resolve; + if (psiMethod.isVarArgs()) { + final int parametersCount = psiMethod.getParameterList().getParametersCount(); + final PsiParameter varargParameter = + psiMethod.getParameterList().getParameters()[parametersCount - 1]; + final PsiType componentType = ((PsiEllipsisType)varargParameter.getType()).getComponentType(); + if (!GenericsHighlightUtil.isReifiableType(componentType)) { + final PsiElement parent = expression.getParent(); + if (parent instanceof PsiMethodCallExpression) { + final PsiExpression[] args = ((PsiMethodCallExpression)parent).getArgumentList().getExpressions(); + if (args.length >= parametersCount) { + if (!GenericsHighlightUtil.isReifiableType(args[args.length - 1].getType())){ + warningsElements.add(expression); + } + } + } + } + } + } + } + }); + } + + private static boolean collectCommentSuppresses(PsiElement psiElement, Set tools2Suppress) { + final Matcher matcher = SuppressionUtil.SUPPRESS_IN_LINE_COMMENT_PATTERN.matcher(psiElement.getText()); + if (matcher.matches()) { + final String inspections = matcher.group(1); + final String[] toolsIds = inspections.split("[, ]"); + for (String toolsId : toolsIds) { + final String id = toolsId.trim(); + if (!id.isEmpty()) { + tools2Suppress.add(id); + } + } + return true; + } + return false; + } + + private static class RemoveUncheckedWarningFix implements LocalQuickFix { + @NonNls private static final String UNCHECKED = "unchecked"; + + @NotNull + @Override + public String getName() { + return "Remove redundant \"unchecked\" suppression"; + } + + @NotNull + @Override + public String getFamilyName() { + return getName(); + } + + @Override + public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { + final PsiElement psiElement = descriptor.getPsiElement(); + if (psiElement instanceof PsiComment) { + final Set tools2Suppress = new LinkedHashSet(); + if (collectCommentSuppresses(psiElement, tools2Suppress)) { + tools2Suppress.remove(UNCHECKED); + if (tools2Suppress.isEmpty()) { + psiElement.delete(); + } else { + psiElement.replace(JavaPsiFacade.getElementFactory(project).createCommentFromText("//" + SuppressionUtil.SUPPRESS_INSPECTIONS_TAG_NAME + " " + StringUtil + .join(tools2Suppress, ", "), psiElement)); + } + } + } else if (psiElement instanceof PsiAnnotation) { + final PsiAnnotation annotation = (PsiAnnotation)psiElement; + final PsiModifierList owner = (PsiModifierList)annotation.getOwner(); + final PsiModifierListOwner listOwner = PsiTreeUtil.getParentOfType(owner, PsiModifierListOwner.class); + if (listOwner != null) { + final Collection tool2Suppress = SuppressManager.getInstance().getInspectionIdsSuppressedInAnnotation(listOwner); + tool2Suppress.remove(UNCHECKED); + if (tool2Suppress.isEmpty()) { + annotation.delete(); + } else { + annotation.replace(JavaPsiFacade.getElementFactory(project).createAnnotationFromText("@" + annotation.getQualifiedName() + "({" +StringUtil.join(tool2Suppress, new Function() { + @Override + public String fun(String s) { + return "\"" + s + "\""; + } + }, ", ")+ "})", annotation)); + } + } + } + } + } +} diff --git a/java/java-impl/src/com/intellij/codeInspection/ex/StandardInspectionToolsProvider.java b/java/java-impl/src/com/intellij/codeInspection/ex/StandardInspectionToolsProvider.java index 2cb300243ffa..f50c3043a83a 100644 --- a/java/java-impl/src/com/intellij/codeInspection/ex/StandardInspectionToolsProvider.java +++ b/java/java-impl/src/com/intellij/codeInspection/ex/StandardInspectionToolsProvider.java @@ -118,7 +118,8 @@ public class StandardInspectionToolsProvider implements InspectionToolProvider { UnknownGuardInspection.class, ExplicitTypeCanBeDiamondInspection.class, - SafeVarargsCanBeUsedInspection.class + SafeVarargsCanBeUsedInspection.class, + RedundantUncheckedSuppressWarningsInspection.class }; } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after1.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after1.java new file mode 100644 index 000000000000..25e41a1306e1 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after1.java @@ -0,0 +1,13 @@ +// "Remove redundant "unchecked" suppression" "true" +import java.util.ArrayList; + +public class Test { + @SafeVarargs + static void foo(T... t){ + } + + void foo() { + foo(new ArrayList()); + } +} + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after2.java new file mode 100644 index 000000000000..0af660bd58e2 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after2.java @@ -0,0 +1,14 @@ +// "Remove redundant "unchecked" suppression" "true" +import java.util.ArrayList; + +public class Test { + @SafeVarargs + static void foo(T... t){ + } + + void foo() { + //noinspection blah-blah-toolid + foo(new ArrayList()); + } +} + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after4.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after4.java new file mode 100644 index 000000000000..f03fa95114ed --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after4.java @@ -0,0 +1,14 @@ +// "Remove redundant "unchecked" suppression" "true" +import java.util.*; + +public class Test { + @SafeVarargs + static List foo(T... t){ + return null; + } + + void foo() { + List> list = foo(new ArrayList()); + } +} + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after5.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after5.java new file mode 100644 index 000000000000..461a023461cc --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after5.java @@ -0,0 +1,14 @@ +// "Remove redundant "unchecked" suppression" "true" +import java.util.*; + +public class Test { + @SafeVarargs + static List foo(T... t){ + return null; + } + + void foo() { + List> list = foo(new ArrayList()); + } +} + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after6.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after6.java new file mode 100644 index 000000000000..461a023461cc --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after6.java @@ -0,0 +1,14 @@ +// "Remove redundant "unchecked" suppression" "true" +import java.util.*; + +public class Test { + @SafeVarargs + static List foo(T... t){ + return null; + } + + void foo() { + List> list = foo(new ArrayList()); + } +} + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after9.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after9.java new file mode 100644 index 000000000000..1c6b1d4aa710 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/after9.java @@ -0,0 +1,15 @@ +// "Remove redundant "unchecked" suppression" "true" +import java.util.*; + +@SuppressWarnings({"bla-blah-toolid"}) +public class Test { + @SafeVarargs + static List foo(T... t){ + return null; + } + + void foo() { + List> list = foo(new ArrayList()); + } +} + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before1.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before1.java new file mode 100644 index 000000000000..69373d386b3e --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before1.java @@ -0,0 +1,14 @@ +// "Remove redundant "unchecked" suppression" "true" +import java.util.ArrayList; + +public class Test { + @SafeVarargs + static void foo(T... t){ + } + + void foo() { + //noinspection unchecked + foo(new ArrayList()); + } +} + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before2.java new file mode 100644 index 000000000000..78476b03483b --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before2.java @@ -0,0 +1,14 @@ +// "Remove redundant "unchecked" suppression" "true" +import java.util.ArrayList; + +public class Test { + @SafeVarargs + static void foo(T... t){ + } + + void foo() { + //noinspection unchecked,blah-blah-toolid + foo(new ArrayList()); + } +} + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before3.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before3.java new file mode 100644 index 000000000000..f5504c6e31eb --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before3.java @@ -0,0 +1,15 @@ +// "Remove redundant "unchecked" suppression" "false" +import java.util.*; + +public class Test { + @SafeVarargs + static List foo(T... t){ + return null; + } + + void foo() { + //noinspection unchecked + foo(new ArrayList()).addAll(Arrays.asList(new ArrayList); + } +} + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before4.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before4.java new file mode 100644 index 000000000000..38e7b23f4bfe --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before4.java @@ -0,0 +1,15 @@ +// "Remove redundant "unchecked" suppression" "true" +import java.util.*; + +public class Test { + @SafeVarargs + static List foo(T... t){ + return null; + } + + void foo() { + //noinspection unchecked + List> list = foo(new ArrayList()); + } +} + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before5.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before5.java new file mode 100644 index 000000000000..f5de09bdaa1d --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before5.java @@ -0,0 +1,15 @@ +// "Remove redundant "unchecked" suppression" "true" +import java.util.*; + +public class Test { + @SafeVarargs + static List foo(T... t){ + return null; + } + + @SuppressWarnings("unchecked") + void foo() { + List> list = foo(new ArrayList()); + } +} + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before6.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before6.java new file mode 100644 index 000000000000..7a2a6729433e --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before6.java @@ -0,0 +1,15 @@ +// "Remove redundant "unchecked" suppression" "true" +import java.util.*; + +@SuppressWarnings("unchecked") +public class Test { + @SafeVarargs + static List foo(T... t){ + return null; + } + + void foo() { + List> list = foo(new ArrayList()); + } +} + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before7.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before7.java new file mode 100644 index 000000000000..36acd8f93a25 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before7.java @@ -0,0 +1,15 @@ +// "Remove redundant "unchecked" suppression" "false" +import java.util.*; + +@SuppressWarnings("unchecked") +public class Test { + @SafeVarargs + static List foo(T... t){ + return null; + } + + void foo() { + foo(new ArrayList()).addAll(Arrays.asList(new ArrayList); + } +} + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before8.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before8.java new file mode 100644 index 000000000000..fea4b7439a40 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before8.java @@ -0,0 +1,15 @@ +// "Remove redundant "unchecked" suppression" "false" +import java.util.*; + +@SuppressWarnings("ALL") +public class Test { + @SafeVarargs + static List foo(T... t){ + return null; + } + + void foo() { + List> list = foo(new ArrayList()); + } +} + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before9.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before9.java new file mode 100644 index 000000000000..e877359e5234 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs/before9.java @@ -0,0 +1,15 @@ +// "Remove redundant "unchecked" suppression" "true" +import java.util.*; + +@SuppressWarnings({"unchecked", "bla-blah-toolid"}) +public class Test { + @SafeVarargs + static List foo(T... t){ + return null; + } + + void foo() { + List> list = foo(new ArrayList()); + } +} + diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/quickFix/RemoveRedundantUncheckedSuppressionTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/quickFix/RemoveRedundantUncheckedSuppressionTest.java new file mode 100644 index 000000000000..7f2d28816f63 --- /dev/null +++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/quickFix/RemoveRedundantUncheckedSuppressionTest.java @@ -0,0 +1,46 @@ +/* + * Copyright 2000-2011 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.codeInspection.LocalInspectionTool; +import com.intellij.codeInspection.RedundantUncheckedSuppressWarningsInspection; +import com.intellij.codeInspection.SafeVarargsCanBeUsedInspection; +import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.openapi.projectRoots.impl.JavaSdkImpl; + + +public class RemoveRedundantUncheckedSuppressionTest extends LightQuickFixTestCase { + + @Override + protected Sdk getProjectJDK() { + return JavaSdkImpl.getMockJdk17(); + } + + @Override + protected LocalInspectionTool[] configureLocalInspectionTools() { + return new LocalInspectionTool[]{ + new RedundantUncheckedSuppressWarningsInspection(), + }; + } + + public void test() throws Exception { doAllTests(); } + + @Override + protected String getBasePath() { + return "/codeInsight/daemonCodeAnalyzer/quickFix/redundantUncheckedVarargs"; + } + +} \ No newline at end of file diff --git a/resources-en/src/inspectionDescriptions/RedundantUncheckedSuppress.html b/resources-en/src/inspectionDescriptions/RedundantUncheckedSuppress.html new file mode 100644 index 000000000000..2858e7d40ff2 --- /dev/null +++ b/resources-en/src/inspectionDescriptions/RedundantUncheckedSuppress.html @@ -0,0 +1,6 @@ + + +@SafeVarargs annotation (since Java 1.7) suppresses unchecked warnings about parameterized array creation at call sites. +This inspection reports all suppressed unchecked warnings which are safe to remove because @SafeVarargs annotation on corresponding method declaration. + + \ No newline at end of file