diff options
Diffstat (limited to 'plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig')
13 files changed, 246 insertions, 133 deletions
diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/BaseInspectionVisitor.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/BaseInspectionVisitor.java index 1ba34a6235d8..d792a1ae1101 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/BaseInspectionVisitor.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/BaseInspectionVisitor.java @@ -1,5 +1,5 @@ /* - * Copyright 2003-2013 Dave Griffith, Bas Leijdekkers + * Copyright 2003-2014 Dave Griffith, Bas Leijdekkers * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -191,8 +191,13 @@ public abstract class BaseInspectionVisitor extends JavaElementVisitor { holder.registerProblem(location, description, highlightType, fixes); } - protected final void registerErrorAtOffset(@NotNull PsiElement location, - int offset, int length, Object... infos) { + protected final void registerErrorAtOffset(@NotNull PsiElement location, int offset, int length, Object... infos) { + registerErrorAtOffset(location, offset, length, ProblemHighlightType.GENERIC_ERROR_OR_WARNING, infos); + } + + protected final void registerErrorAtOffset(@NotNull PsiElement location, int offset, int length, + ProblemHighlightType highlightType, + Object... infos) { if (location.getTextLength() == 0 || length == 0) { return; } @@ -202,7 +207,7 @@ public abstract class BaseInspectionVisitor extends JavaElementVisitor { } final String description = inspection.buildErrorString(infos); final TextRange range = new TextRange(offset, offset + length); - holder.registerProblem(location, range, description, fixes); + holder.registerProblem(location, description, highlightType, range, fixes); } @NotNull diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/abstraction/DeclareCollectionAsInterfaceInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/abstraction/DeclareCollectionAsInterfaceInspection.java index 8db2598dc39f..7f5012f2be76 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/abstraction/DeclareCollectionAsInterfaceInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/abstraction/DeclareCollectionAsInterfaceInspection.java @@ -284,8 +284,10 @@ public class DeclareCollectionAsInterfaceInspection extends BaseInspection { weaklingList.remove(objectClass); if (weaklingList.isEmpty()) { final String typeText = type.getCanonicalText(); - final String interfaceText = - CollectionUtils.getInterfaceForClass(typeText); + final String interfaceText = CollectionUtils.getInterfaceForClass(typeText); + if (interfaceText == null) { + return; + } registerError(nameElement, interfaceText); } else { diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/bugs/MismatchedArrayReadWriteInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/bugs/MismatchedArrayReadWriteInspection.java index 41b391183395..17f7a83316ef 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/bugs/MismatchedArrayReadWriteInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/bugs/MismatchedArrayReadWriteInspection.java @@ -72,8 +72,7 @@ public class MismatchedArrayReadWriteInspection extends BaseInspection { return new MismatchedArrayReadWriteVisitor(); } - private static class MismatchedArrayReadWriteVisitor - extends BaseInspectionVisitor { + private static class MismatchedArrayReadWriteVisitor extends BaseInspectionVisitor { @Override public void visitField(@NotNull PsiField field) { @@ -88,8 +87,7 @@ public class MismatchedArrayReadWriteInspection extends BaseInspection { if (!checkVariable(field, containingClass)) { return; } - final boolean written = - arrayContentsAreWritten(field, containingClass); + final boolean written = arrayContentsAreWritten(field, containingClass); final boolean read = arrayContentsAreRead(field, containingClass); if (written == read) { return; @@ -98,16 +96,13 @@ public class MismatchedArrayReadWriteInspection extends BaseInspection { } @Override - public void visitLocalVariable( - @NotNull PsiLocalVariable variable) { + public void visitLocalVariable(@NotNull PsiLocalVariable variable) { super.visitLocalVariable(variable); - final PsiCodeBlock codeBlock = - PsiTreeUtil.getParentOfType(variable, PsiCodeBlock.class); + final PsiCodeBlock codeBlock = PsiTreeUtil.getParentOfType(variable, PsiCodeBlock.class); if (!checkVariable(variable, codeBlock)) { return; } - final boolean written = - arrayContentsAreWritten(variable, codeBlock); + final boolean written = arrayContentsAreWritten(variable, codeBlock); final boolean read = arrayContentsAreRead(variable, codeBlock); if (written == read) { return; @@ -133,8 +128,7 @@ public class MismatchedArrayReadWriteInspection extends BaseInspection { if (VariableAccessUtils.variableIsReturned(variable, context)) { return false; } - return !VariableAccessUtils.variableIsUsedInArrayInitializer( - variable, context); + return !VariableAccessUtils.variableIsUsedInArrayInitializer(variable, context); } private static boolean arrayContentsAreWritten(PsiVariable variable, @@ -187,26 +181,20 @@ public class MismatchedArrayReadWriteInspection extends BaseInspection { return true; } if (initializer instanceof PsiNewExpression) { - final PsiNewExpression newExpression = - (PsiNewExpression)initializer; - final PsiArrayInitializerExpression arrayInitializer = - newExpression.getArrayInitializer(); - return arrayInitializer == null || - isDefaultArrayInitializer(arrayInitializer); + final PsiNewExpression newExpression = (PsiNewExpression)initializer; + final PsiArrayInitializerExpression arrayInitializer = newExpression.getArrayInitializer(); + return arrayInitializer == null || isDefaultArrayInitializer(arrayInitializer); } else if (initializer instanceof PsiArrayInitializerExpression) { - final PsiArrayInitializerExpression arrayInitializerExpression = - (PsiArrayInitializerExpression)initializer; - final PsiExpression[] initializers = - arrayInitializerExpression.getInitializers(); + final PsiArrayInitializerExpression arrayInitializerExpression = (PsiArrayInitializerExpression)initializer; + final PsiExpression[] initializers = arrayInitializerExpression.getInitializers(); return initializers.length == 0; } return false; } public static boolean variableIsWritten(@NotNull PsiVariable variable, @NotNull PsiElement context) { - final VariableReadWriteVisitor visitor = - new VariableReadWriteVisitor(variable, true); + final VariableReadWriteVisitor visitor = new VariableReadWriteVisitor(variable, true); context.accept(visitor); return visitor.isPassed(); } @@ -272,8 +260,7 @@ public class MismatchedArrayReadWriteInspection extends BaseInspection { final PsiExpression[] arguments = argumentList.getExpressions(); for (int i = 0; i < arguments.length; i++) { final PsiExpression argument = arguments[i]; - if (VariableAccessUtils.mayEvaluateToVariable(argument, - variable)) { + if (VariableAccessUtils.mayEvaluateToVariable(argument, variable)) { if (write && i == 0 && isCallToSystemArraycopy(call)) { return; } @@ -285,49 +272,50 @@ public class MismatchedArrayReadWriteInspection extends BaseInspection { } } - private static boolean isCallToSystemArraycopy( - PsiMethodCallExpression call) { - final PsiReferenceExpression methodExpression = - call.getMethodExpression(); - @NonNls final String name = - methodExpression.getReferenceName(); + private static boolean isCallToSystemArraycopy(PsiMethodCallExpression call) { + final PsiReferenceExpression methodExpression = call.getMethodExpression(); + @NonNls final String name = methodExpression.getReferenceName(); if (!"arraycopy".equals(name)) { return false; } - final PsiExpression qualifier = - methodExpression.getQualifierExpression(); + final PsiExpression qualifier = methodExpression.getQualifierExpression(); if (!(qualifier instanceof PsiReferenceExpression)) { return false; } - final PsiReferenceExpression referenceExpression = - (PsiReferenceExpression)qualifier; - final PsiElement element = - referenceExpression.resolve(); + final PsiReferenceExpression referenceExpression = (PsiReferenceExpression)qualifier; + final PsiElement element = referenceExpression.resolve(); if (!(element instanceof PsiClass)) { return false; } - final PsiClass aClass = (PsiClass)element; - final String qualifiedName = - aClass.getQualifiedName(); - return "java.lang.System".equals(qualifiedName); + return "java.lang.System".equals(((PsiClass)element).getQualifiedName()); } @Override - public void visitNewExpression( - @NotNull PsiNewExpression newExpression) { + public void visitNewExpression(@NotNull PsiNewExpression newExpression) { if (passed) { return; } super.visitNewExpression(newExpression); - final PsiExpressionList argumentList = - newExpression.getArgumentList(); + visitPsiCall(newExpression); + } + + @Override + public void visitEnumConstant(PsiEnumConstant enumConstant) { + if (passed) { + return; + } + super.visitEnumConstant(enumConstant); + visitPsiCall(enumConstant); + } + + private void visitPsiCall(PsiCall newExpression) { + final PsiExpressionList argumentList = newExpression.getArgumentList(); if (argumentList == null) { return; } final PsiExpression[] arguments = argumentList.getExpressions(); for (final PsiExpression argument : arguments) { - if (VariableAccessUtils.mayEvaluateToVariable(argument, - variable)) { + if (VariableAccessUtils.mayEvaluateToVariable(argument, variable)) { passed = true; } } diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/javabeans/PropertyValueSetToItselfInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/javabeans/PropertyValueSetToItselfInspection.java new file mode 100644 index 000000000000..e4ee7c5956bc --- /dev/null +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/javabeans/PropertyValueSetToItselfInspection.java @@ -0,0 +1,102 @@ +/* + * Copyright 2000-2014 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.siyeh.ig.javabeans; + +import com.intellij.psi.*; +import com.intellij.psi.util.PropertyUtil; +import com.siyeh.InspectionGadgetsBundle; +import com.siyeh.ig.BaseInspection; +import com.siyeh.ig.BaseInspectionVisitor; +import com.siyeh.ig.psiutils.EquivalenceChecker; +import com.siyeh.ig.psiutils.ParenthesesUtils; +import org.jetbrains.annotations.Nls; +import org.jetbrains.annotations.NotNull; + +/** + * @author Bas Leijdekkers + */ +public class PropertyValueSetToItselfInspection extends BaseInspection { + + @Nls + @NotNull + @Override + public String getDisplayName() { + return InspectionGadgetsBundle.message("property.value.set.to.itself.display.name"); + } + + @NotNull + @Override + protected String buildErrorString(Object... infos) { + return InspectionGadgetsBundle.message("property.value.set.to.itself.display.name"); + } + + @Override + public BaseInspectionVisitor buildVisitor() { + return new PropertyValueSetToItselfVisitor(); + } + + private static class PropertyValueSetToItselfVisitor extends BaseInspectionVisitor { + + @Override + public void visitMethodCallExpression(PsiMethodCallExpression expression) { + super.visitMethodCallExpression(expression); + final PsiExpressionList argumentList1 = expression.getArgumentList(); + final PsiExpression[] arguments1 = argumentList1.getExpressions(); + if (arguments1.length != 1) { + return; + } + final PsiExpression argument = arguments1[0]; + if (!(argument instanceof PsiMethodCallExpression)) { + return; + } + final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression)argument; + final PsiExpressionList argumentList2 = methodCallExpression.getArgumentList(); + final PsiExpression[] arguments2 = argumentList2.getExpressions(); + if (arguments2.length != 0) { + return; + } + final PsiReferenceExpression methodExpression1 = expression.getMethodExpression(); + final PsiExpression qualifierExpression1 = ParenthesesUtils.stripParentheses(methodExpression1.getQualifierExpression()); + final PsiReferenceExpression methodExpression2 = methodCallExpression.getMethodExpression(); + final PsiExpression qualifierExpression2 = ParenthesesUtils.stripParentheses(methodExpression2.getQualifierExpression()); + if (qualifierExpression1 instanceof PsiReferenceExpression && qualifierExpression2 instanceof PsiReferenceExpression) { + if (!EquivalenceChecker.expressionsAreEquivalent(qualifierExpression1, qualifierExpression2)) { + return; + } + } + else if((qualifierExpression1 != null && + !(qualifierExpression1 instanceof PsiThisExpression) && + !(qualifierExpression1 instanceof PsiSuperExpression)) + || + qualifierExpression2 != null && + !(qualifierExpression2 instanceof PsiThisExpression) && + !(qualifierExpression2 instanceof PsiSuperExpression)) { + return; + } + final PsiMethod method1 = expression.resolveMethod(); + final PsiField fieldOfSetter = PropertyUtil.getFieldOfSetter(method1); + if (fieldOfSetter == null) { + return; + } + final PsiMethod method2 = methodCallExpression.resolveMethod(); + final PsiField fieldOfGetter = PropertyUtil.getFieldOfGetter(method2); + if (!fieldOfSetter.equals(fieldOfGetter)) { + return; + } + registerMethodCallError(expression); + } + } +} diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/migration/IfCanBeSwitchInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/migration/IfCanBeSwitchInspection.java index 5b4c0c9c8305..adfff487443e 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/migration/IfCanBeSwitchInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/migration/IfCanBeSwitchInspection.java @@ -515,7 +515,10 @@ public class IfCanBeSwitchInspection extends BaseInspection { super.readSettings(node); for (Element child : node.getChildren("option")) { if (Comparing.strEqual(child.getAttributeValue("name"), ONLY_SAFE)) { - onlySuggestNullSafe = Boolean.parseBoolean(child.getAttributeValue("value")); + final String value = child.getAttributeValue("value"); + if (value != null) { + onlySuggestNullSafe = Boolean.parseBoolean(value); + } break; } } diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/ImportUtils.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/ImportUtils.java index 375e0f6a8017..9b4a3a832913 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/ImportUtils.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/ImportUtils.java @@ -416,7 +416,7 @@ public class ImportUtils { final List<PsiImportStaticStatement> imports = getMatchingImports(importList, qualifiedName); final int onDemandCount = JavaCodeStyleSettingsFacade.getInstance(project).getNamesCountToUseImportOnDemand(); final PsiElementFactory elementFactory = psiFacade.getElementFactory(); - if (imports.size() < onDemandCount) { + if (imports.size() + 1 < onDemandCount) { importList.add(elementFactory.createImportStaticStatement(aClass, memberName)); } else { diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/InstanceOfUtils.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/InstanceOfUtils.java index 702d84d522ac..fdbc531406de 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/InstanceOfUtils.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/InstanceOfUtils.java @@ -117,6 +117,9 @@ public class InstanceOfUtils { inElse = true; } checkExpression(operand); + if (agreeingInstanceof) { + return; + } } if (inElse && conflictingInstanceof != null) { agreeingInstanceof = false; @@ -215,6 +218,7 @@ public class InstanceOfUtils { (PsiInstanceOfExpression)expression; if (isAgreeing(instanceOfExpression)) { agreeingInstanceof = true; + conflictingInstanceof = null; } else if (isConflicting(instanceOfExpression)) { conflictingInstanceof = instanceOfExpression; diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/WeakestTypeFinder.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/WeakestTypeFinder.java index 1440c58e5113..aade5a56361f 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/WeakestTypeFinder.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/WeakestTypeFinder.java @@ -132,7 +132,7 @@ public class WeakestTypeFinder { else if (referenceParent instanceof PsiVariable) { final PsiVariable variable = (PsiVariable)referenceParent; final PsiType type = variable.getType(); - if (!checkType(type, weakestTypeClasses)) { + if (!type.isAssignableFrom(variableOrMethodType) || !checkType(type, weakestTypeClasses)) { return Collections.emptyList(); } } @@ -251,7 +251,7 @@ public class WeakestTypeFinder { if (!hasUsages) { return Collections.emptyList(); } - weakestTypeClasses = filterAccessibleClasses(weakestTypeClasses, variableOrMethod); + weakestTypeClasses = filterAccessibleClasses(weakestTypeClasses, variableOrMethodClass, variableOrMethod); return weakestTypeClasses; } @@ -442,22 +442,23 @@ public class WeakestTypeFinder { } final PsiExpression lhs = assignmentExpression.getLExpression(); final PsiExpression rhs = assignmentExpression.getRExpression(); + if (rhs == null) { + return false; + } final PsiType lhsType = lhs.getType(); + final PsiType rhsType = rhs.getType(); + if (lhsType == null || rhsType == null || !lhsType.isAssignableFrom(rhsType)) { + return false; + } if (referenceElement.equals(rhs)) { if (!checkType(lhsType, weakestTypeClasses)) { return false; } } - else if (useRighthandTypeAsWeakestTypeInAssignments) { - if (rhs == null) { - return false; - } - if (!(rhs instanceof PsiNewExpression) || !(rhs instanceof PsiTypeCastExpression)) { - final PsiType rhsType = rhs.getType(); - if (lhsType == null || lhsType.equals(rhsType)) { - return false; - } - } + else if (useRighthandTypeAsWeakestTypeInAssignments && + (!(rhs instanceof PsiNewExpression) || !(rhs instanceof PsiTypeCastExpression)) && + lhsType.equals(rhsType)) { + return false; } return true; } @@ -546,14 +547,14 @@ public class WeakestTypeFinder { return true; } - public static Set<PsiClass> filterAccessibleClasses(Set<PsiClass> weakestTypeClasses, PsiElement context) { + public static Set<PsiClass> filterAccessibleClasses(Set<PsiClass> weakestTypeClasses, PsiClass upperBound, PsiElement context) { final Set<PsiClass> result = new HashSet<PsiClass>(); for (PsiClass weakestTypeClass : weakestTypeClasses) { - if (PsiUtil.isAccessible(weakestTypeClass, context, null)) { + if (PsiUtil.isAccessible(weakestTypeClass, context, null) && !weakestTypeClass.isDeprecated()) { result.add(weakestTypeClass); continue; } - final PsiClass visibleInheritor = getVisibleInheritor(weakestTypeClass, context); + final PsiClass visibleInheritor = getVisibleInheritor(weakestTypeClass, upperBound, context); if (visibleInheritor != null) { result.add(visibleInheritor); } @@ -562,16 +563,16 @@ public class WeakestTypeFinder { } @Nullable - private static PsiClass getVisibleInheritor(@NotNull PsiClass superClass, PsiElement context) { + private static PsiClass getVisibleInheritor(@NotNull PsiClass superClass, PsiClass upperBound, PsiElement context) { final Query<PsiClass> search = DirectClassInheritorsSearch.search(superClass, context.getResolveScope()); final Project project = superClass.getProject(); for (PsiClass aClass : search) { - if (superClass.isInheritor(aClass, true)) { + if (aClass.isInheritor(superClass, true) && upperBound.isInheritor(aClass, true)) { if (PsiUtil.isAccessible(project, aClass, context, null)) { return aClass; } else { - return getVisibleInheritor(aClass, context); + return getVisibleInheritor(aClass, upperBound, context); } } } diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/SimplifiableAnnotationInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/SimplifiableAnnotationInspection.java index 794716ba0412..e45f06cac284 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/SimplifiableAnnotationInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/SimplifiableAnnotationInspection.java @@ -16,9 +16,10 @@ package com.siyeh.ig.style; import com.intellij.codeInspection.ProblemDescriptor; +import com.intellij.codeInspection.ProblemHighlightType; import com.intellij.openapi.project.Project; -import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; +import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtilCore; import com.intellij.psi.util.TypeConversionUtil; import com.intellij.util.IncorrectOperationException; @@ -46,30 +47,30 @@ public class SimplifiableAnnotationInspection extends BaseInspection { @NotNull @Override protected String buildErrorString(Object... infos) { - return InspectionGadgetsBundle.message("simplifiable.annotation.problem.descriptor"); + if (((Boolean)infos[0]).booleanValue()) { + return InspectionGadgetsBundle.message("simplifiable.annotation.whitespace.problem.descriptor"); + } + else { + return InspectionGadgetsBundle.message("simplifiable.annotation.problem.descriptor"); + } } @Override protected InspectionGadgetsFix buildFix(Object... infos) { - final PsiAnnotation annotation = (PsiAnnotation)infos[0]; - return new SimplifiableAnnotationFix(annotation); + return new SimplifiableAnnotationFix(); } private static class SimplifiableAnnotationFix extends InspectionGadgetsFix { - private final String replacement; - - public SimplifiableAnnotationFix(PsiAnnotation annotation) { - this.replacement = buildAnnotationText(annotation, new StringBuilder()).toString(); - } + public SimplifiableAnnotationFix() {} @Override @NotNull public String getName() { - return InspectionGadgetsBundle.message("simplifiable.annotation.quickfix", - StringUtil.shortenTextWithEllipsis(replacement, 50, 0, true)); + return InspectionGadgetsBundle.message("simplifiable.annotation.quickfix"); } - @Override + + @Override @NotNull public String getFamilyName() { return getName(); @@ -78,23 +79,25 @@ public class SimplifiableAnnotationInspection extends BaseInspection { @Override protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { final PsiElement element = descriptor.getPsiElement(); - if (!(element instanceof PsiAnnotation)) { + final PsiAnnotation annotation = PsiTreeUtil.getParentOfType(element, PsiAnnotation.class); + if (annotation == null) { return; } final PsiElementFactory factory = JavaPsiFacade.getElementFactory(project); - final PsiAnnotation annotation = factory.createAnnotationFromText(replacement, element); - element.replace(annotation); + final String annotationText = buildAnnotationText(annotation); + final PsiAnnotation newAnnotation = factory.createAnnotationFromText(annotationText, element); + annotation.replace(newAnnotation); } - private static StringBuilder buildAnnotationText(PsiAnnotation annotation, StringBuilder out) { - out.append('@'); + private static String buildAnnotationText(PsiAnnotation annotation) { + final StringBuilder out = new StringBuilder("@"); final PsiJavaCodeReferenceElement nameReferenceElement = annotation.getNameReferenceElement(); assert nameReferenceElement != null; out.append(nameReferenceElement.getText()); final PsiAnnotationParameterList parameterList = annotation.getParameterList(); final PsiNameValuePair[] attributes = parameterList.getAttributes(); if (attributes.length == 0) { - return out; + return out.toString(); } out.append('('); if (attributes.length == 1) { @@ -116,7 +119,7 @@ public class SimplifiableAnnotationInspection extends BaseInspection { } } out.append(')'); - return out; + return out.toString(); } private static StringBuilder buildAttributeValueText(PsiAnnotationMemberValue value, StringBuilder out) { @@ -128,7 +131,7 @@ public class SimplifiableAnnotationInspection extends BaseInspection { } } else if (value instanceof PsiAnnotation) { - return buildAnnotationText((PsiAnnotation)value, out); + return out.append(buildAnnotationText((PsiAnnotation)value)); } return out.append(value.getText()); } @@ -151,36 +154,36 @@ public class SimplifiableAnnotationInspection extends BaseInspection { } final PsiNameValuePair[] attributes = parameterList.getAttributes(); final PsiElement[] annotationChildren = annotation.getChildren(); - if (annotationChildren.length >= 2 && annotationChildren[1] instanceof PsiWhiteSpace) { - if (!containsError(annotation)) { - registerError(annotation, annotation); - } + if (annotationChildren.length >= 2 && annotationChildren[1] instanceof PsiWhiteSpace && !containsError(annotation)) { + registerError(annotationChildren[1], Boolean.TRUE); } - else if (attributes.length == 0) { - final PsiElement[] children = parameterList.getChildren(); - if (children.length <= 0) { - return; - } - if (!containsError(annotation)) { - registerError(annotation, annotation); + if (attributes.length == 0) { + if (parameterList.getChildren().length > 0 && !containsError(annotation)) { + registerError(parameterList, ProblemHighlightType.LIKE_UNUSED_SYMBOL, Boolean.FALSE); } } else if (attributes.length == 1) { final PsiNameValuePair attribute = attributes[0]; - @NonNls final String name = attribute.getName(); + final PsiIdentifier identifier = attribute.getNameIdentifier(); final PsiAnnotationMemberValue attributeValue = attribute.getValue(); - if (!PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME.equals(name)) { - if (!(attributeValue instanceof PsiArrayInitializerMemberValue)) { - return; - } - final PsiArrayInitializerMemberValue arrayValue = (PsiArrayInitializerMemberValue)attributeValue; - final PsiAnnotationMemberValue[] initializers = arrayValue.getInitializers(); - if (initializers.length != 1) { - return; + if (identifier != null && attributeValue != null) { + @NonNls final String name = attribute.getName(); + if (PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME.equals(name) && !containsError(annotation)) { + registerErrorAtOffset(attribute, 0, attributeValue.getStartOffsetInParent(), ProblemHighlightType.LIKE_UNUSED_SYMBOL, + Boolean.FALSE); } } + if (!(attributeValue instanceof PsiArrayInitializerMemberValue)) { + return; + } + final PsiArrayInitializerMemberValue arrayValue = (PsiArrayInitializerMemberValue)attributeValue; + final PsiAnnotationMemberValue[] initializers = arrayValue.getInitializers(); + if (initializers.length != 1) { + return; + } if (!containsError(annotation)) { - registerError(annotation, annotation); + registerError(arrayValue.getFirstChild(), ProblemHighlightType.LIKE_UNUSED_SYMBOL, Boolean.FALSE); + registerError(arrayValue.getLastChild(), ProblemHighlightType.LIKE_UNUSED_SYMBOL, Boolean.FALSE); } } else if (attributes.length > 1) { @@ -189,15 +192,15 @@ public class SimplifiableAnnotationInspection extends BaseInspection { if (!(value instanceof PsiArrayInitializerMemberValue)) { continue; } - final PsiArrayInitializerMemberValue arrayInitializerMemberValue = (PsiArrayInitializerMemberValue)value; - final PsiAnnotationMemberValue[] initializers = arrayInitializerMemberValue.getInitializers(); + final PsiArrayInitializerMemberValue arrayValue = (PsiArrayInitializerMemberValue)value; + final PsiAnnotationMemberValue[] initializers = arrayValue.getInitializers(); if (initializers.length != 1) { continue; } if (!containsError(annotation)) { - registerError(annotation, annotation); + registerError(arrayValue.getFirstChild(), ProblemHighlightType.LIKE_UNUSED_SYMBOL, Boolean.FALSE); + registerError(arrayValue.getLastChild(), ProblemHighlightType.LIKE_UNUSED_SYMBOL, Boolean.FALSE); } - return; } } } diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/StringBufferReplaceableByStringInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/StringBufferReplaceableByStringInspection.java index 4747e7426fd7..70b620f9434c 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/StringBufferReplaceableByStringInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/StringBufferReplaceableByStringInspection.java @@ -20,7 +20,6 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; import com.intellij.psi.util.PsiTreeUtil; -import com.intellij.util.IncorrectOperationException; import com.intellij.util.containers.ContainerUtil; import com.siyeh.InspectionGadgetsBundle; import com.siyeh.ig.BaseInspection; @@ -86,7 +85,7 @@ public class StringBufferReplaceableByStringInspection extends BaseInspection { } @Override - protected void doFix(Project project, ProblemDescriptor descriptor) throws IncorrectOperationException { + protected void doFix(Project project, ProblemDescriptor descriptor) { final PsiElement element = descriptor.getPsiElement(); final PsiElement parent = element.getParent(); if (!(parent instanceof PsiVariable)) { @@ -290,6 +289,9 @@ public class StringBufferReplaceableByStringInspection extends BaseInspection { methodCallExpression = (PsiMethodCallExpression)grandParent; parent = methodCallExpression.getParent(); grandParent = parent.getParent(); + if ("toString".equals(methodCallExpression.getMethodExpression().getReferenceName())) { + break; + } } if (buildStringExpression(methodCallExpression, myBuilder) == null) { myProblem = true; diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/UnnecessaryEnumModifierInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/UnnecessaryEnumModifierInspection.java index 2aa72fae7bbe..7d8d9558ef53 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/UnnecessaryEnumModifierInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/UnnecessaryEnumModifierInspection.java @@ -1,5 +1,5 @@ /* - * Copyright 2003-2012 Dave Griffith, Bas Leijdekkers + * Copyright 2003-2014 Dave Griffith, Bas Leijdekkers * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,6 +17,7 @@ package com.siyeh.ig.style; import com.intellij.codeInspection.CleanupLocalInspectionTool; import com.intellij.codeInspection.ProblemDescriptor; +import com.intellij.codeInspection.ProblemHighlightType; import com.intellij.openapi.project.Project; import com.intellij.psi.*; import com.intellij.util.IncorrectOperationException; @@ -112,7 +113,7 @@ public class UnnecessaryEnumModifierInspection extends BaseInspection implements for (final PsiElement child : children) { final String text = child.getText(); if (PsiModifier.STATIC.equals(text)) { - registerError(child, child, aClass); + registerError(child, ProblemHighlightType.LIKE_UNUSED_SYMBOL, child, aClass); } } } @@ -131,7 +132,7 @@ public class UnnecessaryEnumModifierInspection extends BaseInspection implements for (final PsiElement child : children) { final String text = child.getText(); if (PsiModifier.PRIVATE.equals(text)) { - registerError(child, child, method); + registerError(child, ProblemHighlightType.LIKE_UNUSED_SYMBOL, child, method); } } } diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/UnnecessaryInterfaceModifierInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/UnnecessaryInterfaceModifierInspection.java index 310cc20c30b6..a0718c07fa8f 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/UnnecessaryInterfaceModifierInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/UnnecessaryInterfaceModifierInspection.java @@ -1,5 +1,5 @@ /* - * Copyright 2003-2012 Dave Griffith, Bas Leijdekkers + * Copyright 2003-2014 Dave Griffith, Bas Leijdekkers * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,6 +17,7 @@ package com.siyeh.ig.style; import com.intellij.codeInspection.CleanupLocalInspectionTool; import com.intellij.codeInspection.ProblemDescriptor; +import com.intellij.codeInspection.ProblemHighlightType; import com.intellij.openapi.project.Project; import com.intellij.psi.*; import com.intellij.psi.util.PsiUtil; @@ -214,7 +215,7 @@ public class UnnecessaryInterfaceModifierInspection extends BaseInspection imple } for (PsiElement child : children) { if (modifiers.contains(child.getText())) { - registerError(child, redundantModifiers.toString(), list); + registerError(child, ProblemHighlightType.LIKE_UNUSED_SYMBOL, redundantModifiers.toString(), list); } } } diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/UnnecessarySemicolonInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/UnnecessarySemicolonInspection.java index c1a75887c6aa..36f5af9408df 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/UnnecessarySemicolonInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/style/UnnecessarySemicolonInspection.java @@ -1,5 +1,5 @@ /* - * Copyright 2003-2009 Dave Griffith, Bas Leijdekkers + * Copyright 2003-2014 Dave Griffith, Bas Leijdekkers * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,6 +17,7 @@ package com.siyeh.ig.style; import com.intellij.codeInspection.CleanupLocalInspectionTool; import com.intellij.codeInspection.ProblemDescriptor; +import com.intellij.codeInspection.ProblemHighlightType; import com.intellij.openapi.project.Project; import com.intellij.psi.*; import com.intellij.psi.tree.IElementType; @@ -111,7 +112,7 @@ public class UnnecessarySemicolonInspection extends BaseInspection implements Cl private void findTopLevelSemicolons(PsiElement element) { for (PsiElement sibling = element.getFirstChild(); sibling != null; sibling = skipForwardWhiteSpacesAndComments(sibling)) { if (PsiUtil.isJavaToken(sibling, JavaTokenType.SEMICOLON)) { - registerError(sibling); + registerError(sibling, ProblemHighlightType.LIKE_UNUSED_SYMBOL); } } } @@ -149,7 +150,7 @@ public class UnnecessarySemicolonInspection extends BaseInspection implements Cl if (next == null || !next.equals(aClass.getRBrace())) { return; } - registerError(element); + registerError(element, ProblemHighlightType.LIKE_UNUSED_SYMBOL); } private void findUnnecessarySemicolonsAfterEnumConstants( @@ -171,11 +172,11 @@ public class UnnecessarySemicolonInspection extends BaseInspection implements Cl if (!JavaTokenType.COMMA.equals(prevTokenType) && !JavaTokenType.LBRACE.equals( prevTokenType)) { - registerError(child); + registerError(child, ProblemHighlightType.LIKE_UNUSED_SYMBOL); } } else { - registerError(child); + registerError(child, ProblemHighlightType.LIKE_UNUSED_SYMBOL); } } } @@ -207,7 +208,7 @@ public class UnnecessarySemicolonInspection extends BaseInspection implements Cl if (semicolon == null) { return; } - registerError(semicolon); + registerError(semicolon, ProblemHighlightType.LIKE_UNUSED_SYMBOL); } } @@ -218,7 +219,7 @@ public class UnnecessarySemicolonInspection extends BaseInspection implements Cl if (last instanceof PsiJavaToken && ((PsiJavaToken)last).getTokenType() == JavaTokenType.RPARENTH) { final PsiElement prev = skipBackwardWhiteSpacesAndComments(last); if (prev instanceof PsiJavaToken && ((PsiJavaToken)prev).getTokenType() == JavaTokenType.SEMICOLON) { - registerError(prev); + registerError(prev, ProblemHighlightType.LIKE_UNUSED_SYMBOL); } } } |